def map_wms(request, mapid):
"""
Publish local map layers as group layer in local OWS.
/maps/:id/wms
GET: return endpoint information for group layer,
PUT: update existing or create new group layer.
"""
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
if request.method == 'PUT':
try:
layerGroupName = map_obj.publish_layer_group()
response = dict(
layerGroupName=layerGroupName,
ows=getattr(ogc_server_settings, 'ows', ''),
)
register_event(request, EventType.EVENT_PUBLISH, map_obj)
return HttpResponse(json.dumps(response),
content_type="application/json")
except Exception:
return HttpResponseServerError()
if request.method == 'GET':
response = dict(
layerGroupName=getattr(map_obj.layer_group, 'name', ''),
ows=getattr(ogc_server_settings, 'ows', ''),
)
return HttpResponse(json.dumps(response),
content_type="application/json")
return HttpResponseNotAllowed(['PUT', 'GET'])
def map_remove(request, mapid, template='maps/map_remove.html'):
''' Delete a map, and its constituent layers. '''
map_obj = _resolve_map(request, mapid, 'base.delete_resourcebase',
_PERMISSION_MSG_VIEW)
if request.method == 'GET':
return render(request, template, context={"map": map_obj})
elif request.method == 'POST':
if getattr(settings, 'SLACK_ENABLED', False):
slack_message = None
try:
from geonode.contrib.slack.utils import build_slack_message_map
slack_message = build_slack_message_map("map_delete", map_obj)
except Exception:
logger.error("Could not build slack message for delete map.")
result = delete_map.delay(object_id=map_obj.id)
# Attempt to run task synchronously
result.get()
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except Exception:
logger.error("Could not send slack message for delete map.")
else:
result = delete_map.delay(object_id=map_obj.id)
# Attempt to run task synchronously
result.get()
register_event(request, EventType.EVENT_REMOVE, map_obj)
return HttpResponseRedirect(reverse("maps_browse"))
def map_view(request, mapid, layer_name=None,
template='maps/map_view.html'):
"""
The view that returns the map composer opened to
the map with the given map ID.
"""
try:
map_obj = _resolve_map(
request,
mapid,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
except PermissionDenied:
return HttpResponse(_("Not allowed"), status=403)
except Exception:
raise Http404(_("Not found"))
if not map_obj:
raise Http404(_("Not found"))
config = map_obj.viewer_json(request)
if layer_name:
config = add_layers_to_map_config(
request, map_obj, (layer_name, ), False)
register_event(request, EventType.EVENT_VIEW, request.path)
return render(request, template, context={
'config': json.dumps(config),
'map': map_obj,
'preview': getattr(
settings,
'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY',
'mapstore')
})
def map_json(request, mapid):
if request.method == 'GET':
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
return HttpResponse(json.dumps(map_obj.viewer_json(request)))
elif request.method == 'PUT':
if not request.user.is_authenticated:
return HttpResponse(_PERMISSION_MSG_LOGIN,
status=401,
content_type="text/plain")
map_obj = Map.objects.get(id=mapid)
if not request.user.has_perm('change_resourcebase',
map_obj.get_self_resource()):
return HttpResponse(_PERMISSION_MSG_SAVE,
status=401,
content_type="text/plain")
try:
map_obj.update_from_viewer(request.body,
context={
'request': request,
'mapId': mapid,
'map': map_obj
})
register_event(request, EventType.EVENT_CHANGE, map_obj)
return HttpResponse(json.dumps(map_obj.viewer_json(request)))
except ValueError as e:
return HttpResponse(
"The server could not understand the request." + str(e),
content_type="text/plain",
status=400)
def map_metadata_detail(
request,
mapid,
template='maps/map_metadata_detail.html'):
try:
map_obj = _resolve_map(
request,
mapid,
'view_resourcebase')
except PermissionDenied:
return HttpResponse(_("Not allowed"), status=403)
except Exception:
raise Http404(_("Not found"))
if not map_obj:
raise Http404(_("Not found"))
group = None
if map_obj.group:
try:
group = GroupProfile.objects.get(slug=map_obj.group.name)
except GroupProfile.DoesNotExist:
group = None
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith('http') else settings.SITEURL
register_event(request, EventType.EVENT_VIEW_METADATA, map_obj)
return render(request, template, context={
"resource": map_obj,
"group": group,
'SITEURL': site_url
})
def document_metadata_detail(request,
docid,
template='documents/document_metadata_detail.html'
):
try:
document = _resolve_document(request, docid, 'view_resourcebase',
_PERMISSION_MSG_METADATA)
except PermissionDenied:
return HttpResponse(_("Not allowed"), status=403)
except Exception:
raise Http404(_("Not found"))
if not document:
raise Http404(_("Not found"))
group = None
if document.group:
try:
group = GroupProfile.objects.get(slug=document.group.name)
except ObjectDoesNotExist:
group = None
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith(
'http') else settings.SITEURL
register_event(request, EventType.EVENT_VIEW_METADATA, document)
return render(request,
template,
context={
"resource": document,
"group": group,
'SITEURL': site_url
})
def map_remove(request, mapid, template='maps/map_remove.html'):
''' Delete a map, and its constituent layers. '''
try:
map_obj = _resolve_map(
request,
mapid,
'base.delete_resourcebase',
_PERMISSION_MSG_VIEW)
except PermissionDenied:
return HttpResponse(_("Not allowed"), status=403)
except Exception:
raise Http404(_("Not found"))
if not map_obj:
raise Http404(_("Not found"))
if request.method == 'GET':
return render(request, template, context={
"map": map_obj
})
elif request.method == 'POST':
resource_manager.delete(map_obj.uuid, instance=map_obj)
register_event(request, EventType.EVENT_REMOVE, map_obj)
return HttpResponseRedirect(reverse("maps_browse"))
def final_step_view(req, upload_session):
_json_response = None
if not upload_session:
upload_session = _get_upload_session(req)
if upload_session:
import_session = upload_session.import_session
_log('Checking session %s validity', import_session.id)
if not check_import_session_is_valid(
req, upload_session, import_session):
error_msg = upload_session.import_session.tasks[0].error_message
url = "/upload/layer_upload_invalid.html"
_json_response = json_response(
{'url': url,
'status': 'error',
'id': req.GET['id'],
'error_msg': error_msg or 'Import Session is Invalid!',
'success': True
}
)
return _json_response
else:
try:
saved_layer = final_step(upload_session, req.user)
# this response is different then all of the other views in the
# upload as it does not return a response as a json object
_json_response = json_response(
{
'status': 'finished',
'id': req.GET['id'],
'url': saved_layer.get_absolute_url(),
'bbox': saved_layer.bbox_string,
'crs': {
'type': 'name',
'properties': saved_layer.srid
},
'success': True
}
)
register_event(req, EventType.EVENT_UPLOAD, saved_layer)
return _json_response
except LayerNotReady:
force_ajax = '&force_ajax=true' if 'force_ajax' in req.GET and req.GET['force_ajax'] == 'true' else ''
return json_response({'status': 'pending',
'success': True,
'id': req.GET['id'],
'redirect_to': '/upload/final' + "?id=%s%s" % (req.GET['id'], force_ajax)})
else:
# url = reverse('layer_browse') + '?limit={}'.format(settings.CLIENT_RESULTS_LIMIT)
url = "upload/layer_upload_invalid.html"
_json_response = json_response(
{'status': 'error',
'url': url,
'error_msg': 'Upload Session invalid or no more accessible!',
'success': True
}
)
return _json_response
def get_download_response(request, docid, attachment=False):
"""
Returns a download response if user has access to download the document of a given id,
and an http response if they have no permissions to download it.
"""
document = get_object_or_404(Document, pk=docid)
if not request.user.has_perm('base.download_resourcebase',
obj=document.get_self_resource()):
return HttpResponse(loader.render_to_string(
'401.html',
context={
'error_message':
_("You are not allowed to view this document.")
},
request=request),
status=401)
if attachment:
register_event(request, EventType.EVENT_DOWNLOAD, document)
filename = slugify(os.path.splitext(os.path.basename(document.title))[0])
if document.files and storage_manager.exists(document.files[0]):
return DownloadResponse(storage_manager.open(document.files[0]).file,
basename=f'{filename}.{document.extension}',
attachment=attachment)
return HttpResponse("File is not available", status=404)
def document_remove(request, docid, template='documents/document_remove.html'):
try:
document = _resolve_document(
request,
docid,
'base.delete_resourcebase',
_PERMISSION_MSG_DELETE)
if request.method == 'GET':
return render(request, template, context={
"document": document
})
if request.method == 'POST':
document.delete()
register_event(request, EventType.EVENT_REMOVE, document)
return HttpResponseRedirect(reverse("document_browse"))
else:
return HttpResponse("Not allowed", status=403)
except PermissionDenied:
return HttpResponse(
'You are not allowed to delete this document',
content_type="text/plain",
status=401
)
def map_view(request, mapid, layer_name=None, template='maps/map_view.html'):
"""
The view that returns the map composer opened to
the map with the given map ID.
"""
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
config = map_obj.viewer_json(request)
if layer_name:
config = add_layers_to_map_config(request, map_obj, (layer_name, ),
False)
register_event(request, EventType.EVENT_VIEW, request.path)
return render(request,
template,
context={
'config':
json.dumps(config),
'map':
map_obj,
'preview':
getattr(settings, 'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY',
'mapstore')
})
def form_valid(self, form):
"""
If the form is valid, save the associated model.
"""
self.object = form.save()
register_event(self.request, EventType.EVENT_CHANGE, self.object)
return HttpResponseRedirect(
reverse('document_metadata', args=(self.object.id, )))
def map_embed(request, mapid=None, template='maps/map_embed.html'):
if mapid is None:
config = default_map_config(request)[0]
else:
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
config = map_obj.viewer_json(request)
register_event(request, EventType.EVENT_VIEW, map_obj)
return render(request, template, context={'config': json.dumps(config)})
def document_download(request, docid):
document = get_object_or_404(Document, pk=docid)
if not request.user.has_perm(
'base.download_resourcebase',
obj=document.get_self_resource()):
return HttpResponse(
loader.render_to_string(
'401.html', context={
'error_message': _("You are not allowed to view this document.")}, request=request), status=401)
register_event(request, EventType.EVENT_DOWNLOAD, document)
return DownloadResponse(document.doc_file)
def form_valid(self, form):
"""
If the form is valid, save the associated model.
"""
self.object = resource_manager.replace(
self.object,
vals={
'files': form.cleaned_data.get('doc_file'),
'doc_url': form.cleaned_data.get('doc_url'),
'user': self.request.user
})
register_event(self.request, EventType.EVENT_CHANGE, self.object)
return HttpResponseRedirect(
reverse('document_detail', args=(self.object.id, )))
def new_map_json(request):
if request.method == 'GET':
map_obj, config = new_map_config(request)
if isinstance(config, HttpResponse):
return config
else:
return HttpResponse(config)
elif request.method == 'POST':
if not request.user.is_authenticated:
return HttpResponse(
'You must be logged in to save new maps',
content_type="text/plain",
status=401
)
map_obj = resource_manager.create(
None,
resource_type=Map,
defaults=dict(
zoom=0,
center_x=0,
center_y=0,
owner=request.user
)
)
resource_manager.set_permissions(None, instance=map_obj, permissions=None, created=True)
# If the body has been read already, use an empty string.
# See https://github.com/django/django/commit/58d555caf527d6f1bdfeab14527484e4cca68648
# for a better exception to catch when we move to Django 1.7.
try:
body = request.body
except Exception:
body = ''
try:
map_obj.update_from_viewer(body, context={'request': request, 'mapId': map_obj.id, 'map': map_obj})
except ValueError as e:
return HttpResponse(str(e), status=400)
else:
register_event(request, EventType.EVENT_UPLOAD, map_obj)
return HttpResponse(
json.dumps({'id': map_obj.id}),
status=200,
content_type='application/json'
)
else:
return HttpResponse(status=405)
def new_map_json(request):
if request.method == 'GET':
map_obj, config = new_map_config(request)
if isinstance(config, HttpResponse):
return config
else:
return HttpResponse(config)
elif request.method == 'POST':
if not request.user.is_authenticated():
return HttpResponse(
'You must be logged in to save new maps',
content_type="text/plain",
status=401
)
map_obj = Map(owner=request.user, zoom=0,
center_x=0, center_y=0)
map_obj.save()
map_obj.set_default_permissions()
map_obj.handle_moderated_uploads()
# If the body has been read already, use an empty string.
# See https://github.com/django/django/commit/58d555caf527d6f1bdfeab14527484e4cca68648
# for a better exception to catch when we move to Django 1.7.
try:
body = request.body
except Exception:
body = ''
try:
map_obj.update_from_viewer(body, context={'request': request, 'mapId': map_obj.id, 'map': map_obj})
MapSnapshot.objects.create(
config=clean_config(body),
map=map_obj,
user=request.user)
except ValueError as e:
return HttpResponse(str(e), status=400)
else:
register_event(request, 'upload', map_obj)
return HttpResponse(
json.dumps({'id': map_obj.id}),
status=200,
content_type='application/json'
)
else:
return HttpResponse(status=405)
def map_metadata_detail(
request,
mapid,
template='maps/map_metadata_detail.html'):
map_obj = _resolve_map(request, mapid, 'view_resourcebase')
group = None
if map_obj.group:
try:
group = GroupProfile.objects.get(slug=map_obj.group.name)
except GroupProfile.DoesNotExist:
group = None
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith('http') else settings.SITEURL
register_event(request, EventType.EVENT_VIEW_METADATA, map_obj)
return render(request, template, context={
"resource": map_obj,
"group": group,
'SITEURL': site_url
})
def get_context_data(self, **kwargs):
context = super(MetadataDetail, self).get_context_data(**kwargs)
id = kwargs['id']
map = self.get_map_object(id)
group = None
if map.group:
try:
group = GroupProfile.objects.get(slug=map.group.name)
except GroupProfile.DoesNotExist:
group = None
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith('http') else settings.SITEURL
register_event(self.request, EventType.EVENT_VIEW_METADATA, map)
context.update({
"resource": map,
"group": group,
'SITEURL': site_url,
"documents": get_related_documents(map)
})
return context
def document_download(request, docid):
document = get_object_or_404(Document, pk=docid)
if settings.MONITORING_ENABLED and document:
dtitle = getattr(document, 'alternate', None) or document.title
request.register_event('upload', 'document', dtitle)
if not request.user.has_perm('base.download_resourcebase',
obj=document.get_self_resource()):
return HttpResponse(loader.render_to_string(
'401.html',
context={
'error_message':
_("You are not allowed to view this document.")
},
request=request),
status=401)
register_event(request, 'download', document)
return DownloadResponse(document.doc_file)
def geoapp_remove(request, geoappid, template='apps/app_remove.html'):
try:
geoapp_obj = _resolve_geoapp(request, geoappid,
'base.delete_resourcebase',
_PERMISSION_MSG_DELETE)
except PermissionDenied:
return HttpResponse(_("Not allowed"), status=403)
except Exception:
raise Http404(_("Not found"))
if not geoapp_obj:
raise Http404(_("Not found"))
if request.method == 'GET':
return render(request, template, context={"resource": geoapp_obj})
elif request.method == 'POST':
geoapp_obj.delete()
register_event(request, EventType.EVENT_REMOVE, geoapp_obj)
return HttpResponseRedirect(reverse("apps_browse"))
else:
return HttpResponse("Not allowed", status=403)
def document_remove(request, docid, template='documents/document_remove.html'):
try:
document = _resolve_document(request, docid,
'base.delete_resourcebase',
_PERMISSION_MSG_DELETE)
except PermissionDenied:
return HttpResponse(_("Not allowed"), status=403)
except Exception:
raise Http404(_("Not found"))
if not document:
raise Http404(_("Not found"))
if request.method == 'GET':
return render(request, template, context={"document": document})
if request.method == 'POST':
document.delete()
register_event(request, EventType.EVENT_REMOVE, document)
return HttpResponseRedirect(reverse("document_browse"))
else:
return HttpResponse(_("Not allowed"), status=403)
def document_metadata_detail(
request,
docid,
template='documents/document_metadata_detail.html'):
document = _resolve_document(
request,
docid,
'view_resourcebase',
_PERMISSION_MSG_METADATA)
group = None
if document.group:
try:
group = GroupProfile.objects.get(slug=document.group.name)
except ObjectDoesNotExist:
group = None
site_url = settings.SITEURL.rstrip('/') if settings.SITEURL.startswith('http') else settings.SITEURL
register_event(request, EventType.EVENT_VIEW_METADATA, document)
return render(request, template, context={
"resource": document,
"group": group,
'SITEURL': site_url
})
def map_remove(request, mapid, template='maps/map_remove.html'):
''' Delete a map, and its constituent layers. '''
try:
map_obj = _resolve_map(
request,
mapid,
'base.delete_resourcebase',
_PERMISSION_MSG_VIEW)
except PermissionDenied:
return HttpResponse(_("Not allowed"), status=403)
except Exception:
raise Http404(_("Not found"))
if not map_obj:
raise Http404(_("Not found"))
if request.method == 'GET':
return render(request, template, context={
"map": map_obj
})
elif request.method == 'POST':
if getattr(settings, 'SLACK_ENABLED', False):
slack_message = None
try:
from geonode.contrib.slack.utils import build_slack_message_map
slack_message = build_slack_message_map("map_delete", map_obj)
except Exception:
logger.error("Could not build slack message for delete map.")
delete_map.apply_async((map_obj.id, ))
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except Exception:
logger.error("Could not send slack message for delete map.")
else:
delete_map.apply_async((map_obj.id, ))
register_event(request, EventType.EVENT_REMOVE, map_obj)
return HttpResponseRedirect(reverse("maps_browse"))
def resource_clone(request):
try:
uuid = request.POST['uuid']
resource = resolve_object(request, ResourceBase, {'uuid': uuid},
'base.change_resourcebase')
except PermissionDenied:
return HttpResponse("Not allowed", status=403)
except Exception:
raise Http404("Not found")
if not resource:
raise Http404("Not found")
out = {}
try:
getattr(resource_manager, "copy")(resource.get_real_instance(),
uuid=None,
defaults={
'user': request.user
})
out['success'] = True
out['message'] = _("Resource Cloned Successfully!")
except Exception as e:
logger.exception(e)
out['success'] = False
out['message'] = _(f"Error Occurred while Cloning the Resource: {e}")
out['errors'] = str(e)
if out['success']:
status_code = 200
register_event(request, 'change', resource)
else:
status_code = 400
return HttpResponse(json.dumps(out),
content_type='application/json',
status=status_code)
def document_detail(request, docid):
"""
The view that show details of each document
"""
document = None
try:
document = _resolve_document(
request,
docid,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
except Http404:
return HttpResponse(
loader.render_to_string(
'404.html', context={
}, request=request), status=404)
except PermissionDenied:
return HttpResponse(
loader.render_to_string(
'401.html', context={
'error_message': _("You are not allowed to view this document.")}, request=request), status=403)
if document is None:
return HttpResponse(
'An unknown error has occured.',
content_type="text/plain",
status=401
)
else:
related = get_related_resources(document)
# 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)
group = None
if document.group:
try:
group = GroupProfile.objects.get(slug=document.group.name)
except ObjectDoesNotExist:
group = None
context_dict = {
'perms_list': get_perms(
request.user,
document.get_self_resource()) + get_perms(request.user, document),
'permissions_json': _perms_info_json(document),
'resource': document,
'group': group,
'metadata': metadata,
'imgtypes': IMGTYPES,
'related': related}
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(
request, document)
if getattr(settings, 'EXIF_ENABLED', False):
try:
from geonode.documents.exif.utils import exif_extract_dict
exif = exif_extract_dict(document)
if exif:
context_dict['exif_data'] = exif
except Exception:
logger.error("Exif extraction failed.")
if request.user.is_authenticated:
if getattr(settings, 'FAVORITE_ENABLED', False):
from geonode.favorite.utils import get_favorite_info
context_dict["favorite_info"] = get_favorite_info(request.user, document)
register_event(request, EventType.EVENT_VIEW, document)
return render(
request,
"documents/document_detail.html",
context=context_dict)
def document_metadata(
request,
docid,
template='documents/document_metadata.html',
ajax=True):
document = None
try:
document = _resolve_document(
request,
docid,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
except Http404:
return HttpResponse(
loader.render_to_string(
'404.html', context={
}, request=request), status=404)
except PermissionDenied:
return HttpResponse(
loader.render_to_string(
'401.html', context={
'error_message': _("You are not allowed to edit this document.")}, request=request), status=403)
if document is None:
return HttpResponse(
'An unknown error has occured.',
content_type="text/plain",
status=401
)
else:
poc = document.poc
metadata_author = document.metadata_author
topic_category = document.category
if request.method == "POST":
document_form = DocumentForm(
request.POST,
instance=document,
prefix="resource")
category_form = CategoryForm(request.POST, prefix="category_choice_field", initial=int(
request.POST["category_choice_field"]) if "category_choice_field" in request.POST and
request.POST["category_choice_field"] else None)
tkeywords_form = TKeywordForm(request.POST)
else:
document_form = DocumentForm(instance=document, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
# Keywords from THESAURUS management
doc_tkeywords = document.tkeywords.all()
tkeywords_list = ''
lang = 'en' # TODO: use user's language
if doc_tkeywords and len(doc_tkeywords) > 0:
tkeywords_ids = doc_tkeywords.values_list('id', flat=True)
if hasattr(settings, 'THESAURUS') and settings.THESAURUS:
el = settings.THESAURUS
thesaurus_name = el['name']
try:
t = Thesaurus.objects.get(identifier=thesaurus_name)
for tk in t.thesaurus.filter(pk__in=tkeywords_ids):
tkl = tk.keyword.filter(lang=lang)
if len(tkl) > 0:
tkl_ids = ",".join(
map(str, tkl.values_list('id', flat=True)))
tkeywords_list += "," + \
tkl_ids if len(
tkeywords_list) > 0 else tkl_ids
except Exception:
tb = traceback.format_exc()
logger.error(tb)
tkeywords_form = TKeywordForm(instance=document)
if request.method == "GET":
print("TESTE NO LAYERS!!!")
project = request.GET.get("list_projects")
management_actions = request.GET.get("list_management_actions")
if project:
print("CLIQUEI EM PROJETO!!")
settings.PROJETO_API = True
settings.ACAO_GERENCIAL_API = False
elif management_actions:
print("CLIQUEI EM AÇÃO GERENCIAL")
settings.ACAO_GERENCIAL_API = True
settings.PROJETO_API = False
if request.method == "POST" and document_form.is_valid(
) and category_form.is_valid():
new_poc = document_form.cleaned_data['poc']
new_author = document_form.cleaned_data['metadata_author']
new_keywords = document_form.cleaned_data['keywords']
new_regions = document_form.cleaned_data['regions']
new_embrapa_keywords = document_form.cleaned_data['embrapa_keywords']
new_embrapa_data_quality_statement = document_form.cleaned_data['embrapa_data_quality_statement']
new_embrapa_authors = document_form.cleaned_data['embrapa_autores']
new_category = None
if category_form and 'category_choice_field' in category_form.cleaned_data and\
category_form.cleaned_data['category_choice_field']:
new_category = TopicCategory.objects.get(
id=int(category_form.cleaned_data['category_choice_field']))
print("VIEWS DO DOCUMENTS!!")
if new_poc is None:
if poc is None:
poc_form = ProfileForm(
request.POST,
prefix="poc",
instance=poc)
else:
poc_form = ProfileForm(request.POST, prefix="poc")
if poc_form.is_valid():
if len(poc_form.cleaned_data['profile']) == 0:
# FIXME use form.add_error in django > 1.7
errors = poc_form._errors.setdefault(
'profile', ErrorList())
errors.append(
_('You must set a point of contact for this resource'))
poc = None
if poc_form.has_changed and poc_form.is_valid():
new_poc = poc_form.save()
if new_author is None:
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author",
instance=metadata_author)
else:
author_form = ProfileForm(request.POST, prefix="author")
if author_form.is_valid():
if len(author_form.cleaned_data['profile']) == 0:
# FIXME use form.add_error in django > 1.7
errors = author_form._errors.setdefault(
'profile', ErrorList())
errors.append(
_('You must set an author for this resource'))
metadata_author = None
if author_form.has_changed and author_form.is_valid():
new_author = author_form.save()
document = document_form.instance
if new_poc is not None and new_author is not None:
document.poc = new_poc
document.metadata_author = new_author
document.embrapa_autores.clear()
document.embrapa_autores.add(*new_embrapa_authors)
document.embrapa_data_quality_statement.clear()
document.embrapa_data_quality_statement.add(*new_embrapa_data_quality_statement)
document.embrapa_keywords.clear()
document.embrapa_keywords.add(*new_embrapa_keywords)
document.keywords.clear()
document.keywords.add(*new_keywords)
document.regions.clear()
document.regions.add(*new_regions)
document.category = new_category
document.save()
document_form.save_many2many()
register_event(request, EventType.EVENT_CHANGE_METADATA, document)
if not ajax:
return HttpResponseRedirect(
reverse(
'document_detail',
args=(
document.id,
)))
message = document.id
try:
# Keywords from THESAURUS management
# Rewritten to work with updated autocomplete
if not tkeywords_form.is_valid():
return HttpResponse(json.dumps({'message': "Invalid thesaurus keywords"}, status_code=400))
tkeywords_data = tkeywords_form.cleaned_data['tkeywords']
thesaurus_setting = getattr(settings, 'THESAURUS', None)
if thesaurus_setting:
tkeywords_data = tkeywords_data.filter(
thesaurus__identifier=thesaurus_setting['name']
)
document.tkeywords = tkeywords_data
except Exception:
tb = traceback.format_exc()
logger.error(tb)
return HttpResponse(json.dumps({'message': message}))
# - POST Request Ends here -
# Request.GET
if poc is not None:
# embrapa #
document_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is not None:
document_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
metadata_author_groups = []
if request.user.is_superuser or request.user.is_staff:
metadata_author_groups = GroupProfile.objects.all()
else:
try:
all_metadata_author_groups = chain(
request.user.group_list_all(),
GroupProfile.objects.exclude(
access="private").exclude(access="public-invite"))
except Exception:
all_metadata_author_groups = GroupProfile.objects.exclude(
access="private").exclude(access="public-invite")
[metadata_author_groups.append(item) for item in all_metadata_author_groups
if item not in metadata_author_groups]
if settings.ADMIN_MODERATE_UPLOADS:
if not request.user.is_superuser:
document_form.fields['is_published'].widget.attrs.update(
{'disabled': 'true'})
can_change_metadata = request.user.has_perm(
'change_resourcebase_metadata',
document.get_self_resource())
try:
is_manager = request.user.groupmember_set.all().filter(role='manager').exists()
except Exception:
is_manager = False
if not is_manager or not can_change_metadata:
document_form.fields['is_approved'].widget.attrs.update(
{'disabled': 'true'})
register_event(request, EventType.EVENT_VIEW_METADATA, document)
return render(request, template, context={
"resource": document,
"document": document,
"document_form": document_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
"tkeywords_form": tkeywords_form,
"metadata_author_groups": metadata_author_groups,
"TOPICCATEGORY_MANDATORY": getattr(settings, 'TOPICCATEGORY_MANDATORY', False),
"GROUP_MANDATORY_RESOURCES": getattr(settings, 'GROUP_MANDATORY_RESOURCES', False),
})
def form_valid(self, form):
"""
If the form is valid, save the associated model.
"""
self.object = form.save(commit=False)
self.object.owner = self.request.user
# by default, if RESOURCE_PUBLISHING=True then document.is_published
# must be set to False
# RESOURCE_PUBLISHING works in similar way as ADMIN_MODERATE_UPLOADS,
# but is applied to documents only. ADMIN_MODERATE_UPLOADS has wider
# usage
is_published = not (
settings.RESOURCE_PUBLISHING or settings.ADMIN_MODERATE_UPLOADS)
self.object.is_published = is_published
self.object.save()
form.save_many2many()
self.object.set_permissions(form.cleaned_data['permissions'])
abstract = None
date = None
regions = []
keywords = []
bbox = None
out = {'success': False}
if getattr(settings, 'EXIF_ENABLED', False):
try:
from geonode.documents.exif.utils import exif_extract_metadata_doc
exif_metadata = exif_extract_metadata_doc(self.object)
if exif_metadata:
date = exif_metadata.get('date', None)
keywords.extend(exif_metadata.get('keywords', []))
bbox = exif_metadata.get('bbox', None)
abstract = exif_metadata.get('abstract', None)
except Exception:
logger.error("Exif extraction failed.")
if abstract:
self.object.abstract = abstract
self.object.save()
if date:
self.object.date = date
self.object.date_type = "Creation"
self.object.save()
if len(regions) > 0:
self.object.regions.add(*regions)
if len(keywords) > 0:
self.object.keywords.add(*keywords)
if bbox:
bbox_x0, bbox_x1, bbox_y0, bbox_y1 = bbox
Document.objects.filter(id=self.object.pk).update(
bbox_x0=bbox_x0,
bbox_x1=bbox_x1,
bbox_y0=bbox_y0,
bbox_y1=bbox_y1)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_document, send_slack_message
send_slack_message(
build_slack_message_document(
"document_new", self.object))
except Exception:
logger.error("Could not send slack message for new document.")
register_event(self.request, EventType.EVENT_UPLOAD, self.object)
if self.request.GET.get('no__redirect', False):
out['success'] = True
out['url'] = reverse(
'document_detail',
args=(
self.object.id,
))
if out['success']:
status_code = 200
else:
status_code = 400
return HttpResponse(
json.dumps(out),
content_type='application/json',
status=status_code)
else:
return HttpResponseRedirect(
reverse(
'document_metadata',
args=(
self.object.id,
)))
def download(request, resourceid, sender=Layer):
_not_authorized = _("You are not authorized to download this resource.")
_not_permitted = _("You are not permitted to save or edit this resource.")
_no_files_found = _(
"No files have been found for this resource. Please, contact a system administrator."
)
instance = resolve_object(request,
sender, {'pk': resourceid},
permission='base.download_resourcebase',
permission_msg=_not_permitted)
if isinstance(instance, Layer):
# Create Target Folder
dirpath = tempfile.mkdtemp()
dir_time_suffix = get_dir_time_suffix()
target_folder = os.path.join(dirpath, dir_time_suffix)
if not os.path.exists(target_folder):
os.makedirs(target_folder)
layer_files = []
try:
upload_session = instance.get_upload_session()
if upload_session:
layer_files = [
item for idx, item in enumerate(
LayerFile.objects.filter(
upload_session=upload_session))
]
if layer_files:
# Copy all Layer related files into a temporary folder
for lyr in layer_files:
if storage.exists(str(lyr.file)):
geonode_layer_path = storage.path(str(lyr.file))
shutil.copy2(geonode_layer_path, target_folder)
else:
return HttpResponse(loader.render_to_string(
'401.html',
context={
'error_title': _("No files found."),
'error_message': _no_files_found
},
request=request),
status=404)
# Check we can access the original files
if not layer_files:
return HttpResponse(loader.render_to_string(
'401.html',
context={
'error_title': _("No files found."),
'error_message': _no_files_found
},
request=request),
status=404)
# Let's check for associated SLD files (if any)
try:
for s in instance.styles.all():
sld_file_path = os.path.join(target_folder,
"".join([s.name, ".sld"]))
with open(sld_file_path, "w") as sld_file:
sld_file.write(s.sld_body.strip())
try:
# Collecting headers and cookies
headers, access_token = get_headers(
request, urlsplit(s.sld_url), s.sld_url)
response, content = http_client.get(s.sld_url,
headers=headers,
timeout=TIMEOUT,
user=request.user)
sld_remote_content = response.text
sld_file_path = os.path.join(
target_folder, "".join([s.name, "_remote.sld"]))
with open(sld_file_path, "w") as sld_file:
sld_file.write(sld_remote_content.strip())
except Exception:
traceback.print_exc()
tb = traceback.format_exc()
logger.debug(tb)
except Exception:
traceback.print_exc()
tb = traceback.format_exc()
logger.debug(tb)
# Let's dump metadata
target_md_folder = os.path.join(target_folder, ".metadata")
if not os.path.exists(target_md_folder):
os.makedirs(target_md_folder)
try:
dump_file = os.path.join(target_md_folder,
"".join([instance.name, ".dump"]))
with open(dump_file, 'w') as outfile:
serialized_obj = json_serializer_producer(
model_to_dict(instance))
json.dump(serialized_obj, outfile)
links = Link.objects.filter(resource=instance.resourcebase_ptr)
for link in links:
link_name = slugify(link.name)
link_file = os.path.join(
target_md_folder,
"".join([link_name, ".%s" % link.extension]))
if link.link_type in ('data'):
# Skipping 'data' download links
continue
elif link.link_type in ('metadata', 'image'):
# Dumping metadata files and images
with open(link_file, "wb"):
try:
# Collecting headers and cookies
headers, access_token = get_headers(
request, urlsplit(link.url), link.url)
response, raw = http_client.get(
link.url,
stream=True,
headers=headers,
timeout=TIMEOUT,
user=request.user)
raw.decode_content = True
shutil.copyfileobj(raw, link_file)
except Exception:
traceback.print_exc()
tb = traceback.format_exc()
logger.debug(tb)
elif link.link_type.startswith('OGC'):
# Dumping OGC/OWS links
with open(link_file, "w") as link_file:
link_file.write(link.url.strip())
except Exception:
traceback.print_exc()
tb = traceback.format_exc()
logger.debug(tb)
# ZIP everything and return
target_file_name = "".join([instance.name, ".zip"])
target_file = os.path.join(dirpath, target_file_name)
zip_dir(target_folder, target_file)
register_event(request, 'download', instance)
response = HttpResponse(content=open(target_file, mode='rb'),
status=200,
content_type="application/zip")
response[
'Content-Disposition'] = 'attachment; filename="%s"' % target_file_name
return response
except NotImplementedError:
traceback.print_exc()
tb = traceback.format_exc()
logger.debug(tb)
return HttpResponse(loader.render_to_string(
'401.html',
context={
'error_title': _("No files found."),
'error_message': _no_files_found
},
request=request),
status=404)
return HttpResponse(loader.render_to_string('401.html',
context={
'error_title':
_("Not Authorized"),
'error_message':
_not_authorized
},
request=request),
status=403)
def document_detail(request, docid):
"""
The view that show details of each document
"""
try:
document = _resolve_document(request, docid, 'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
except PermissionDenied:
return HttpResponse(_("Not allowed"), status=403)
except Exception:
raise Http404(_("Not found"))
if not document:
raise Http404(_("Not found"))
permission_manager = ManageResourceOwnerPermissions(document)
permission_manager.set_owner_permissions_according_to_workflow()
# Add metadata_author or poc if missing
document.add_missing_metadata_author_or_poc()
related = get_related_resources(document)
# 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)
# Call this first in order to be sure "perms_list" is correct
permissions_json = _perms_info_json(document)
perms_list = get_perms(request.user,
document.get_self_resource()) + get_perms(
request.user, document)
group = None
if document.group:
try:
group = GroupProfile.objects.get(slug=document.group.name)
except ObjectDoesNotExist:
group = None
access_token = None
if request and request.user:
access_token = get_or_create_token(request.user)
if access_token and not access_token.is_expired():
access_token = access_token.token
else:
access_token = None
AUDIOTYPES = [_e for _e, _t in DOCUMENT_TYPE_MAP.items() if _t == 'audio']
IMGTYPES = [_e for _e, _t in DOCUMENT_TYPE_MAP.items() if _t == 'image']
VIDEOTYPES = [_e for _e, _t in DOCUMENT_TYPE_MAP.items() if _t == 'video']
context_dict = {
'access_token': access_token,
'resource': document,
'perms_list': perms_list,
'permissions_json': permissions_json,
'group': group,
'metadata': metadata,
'audiotypes': AUDIOTYPES,
'imgtypes': IMGTYPES,
'videotypes': VIDEOTYPES,
'mimetypemap': DOCUMENT_MIMETYPE_MAP,
'related': related
}
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, document)
if getattr(settings, 'EXIF_ENABLED', False):
try:
from geonode.documents.exif.utils import exif_extract_dict
exif = exif_extract_dict(document)
if exif:
context_dict['exif_data'] = exif
except Exception:
logger.error("Exif extraction failed.")
if request.user.is_authenticated:
if getattr(settings, 'FAVORITE_ENABLED', False):
from geonode.favorite.utils import get_favorite_info
context_dict["favorite_info"] = get_favorite_info(
request.user, document)
register_event(request, EventType.EVENT_VIEW, document)
return render(request,
"documents/document_detail.html",
context=context_dict)
