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_to_response(template, RequestContext(request, {
"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:
print "Could not build slack message for delete map."
delete_map.delay(object_id=map_obj.id)
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except:
print "Could not send slack message for delete map."
else:
delete_map.delay(object_id=map_obj.id)
return HttpResponseRedirect(reverse("maps_browse"))
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 BaseException:
logger.error("Could not build slack message for delete map.")
delete_map.delay(object_id=map_obj.id)
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except BaseException:
logger.error("Could not send slack message for delete map.")
else:
delete_map.delay(object_id=map_obj.id)
return HttpResponseRedirect(reverse("maps_browse"))
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_to_response(template, RequestContext(request, {
"document": document
}))
if request.method == 'POST':
if getattr(settings, 'SLACK_ENABLED', False):
slack_message = None
try:
from geonode.contrib.slack.utils import build_slack_message_document
slack_message = build_slack_message_document("document_delete", document)
except:
print "Could not build slack message for delete document."
document.delete()
# notify document owner that someone have deleted the document
if request.user != document.owner:
recipient = document.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=document, verb='deleted your document')
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except:
print "Could not send slack message for delete document."
else:
document.delete()
# notify document owner that someone have deleted the document
if request.user != document.owner:
recipient = document.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=document, verb='deleted your document')
return HttpResponseRedirect(reverse("document_browse"))
else:
return HttpResponse("Not allowed", status=403)
except PermissionDenied:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to delete this document.")})), status=401)
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_to_response(template, RequestContext(request, {
"document": document
}))
if request.method == 'POST':
try: #^^
main = Main.objects.get(document=document) #^^
main.delete() #^^
except: #^^
pass #^^
if getattr(settings, 'SLACK_ENABLED', False):
slack_message = None
try:
from geonode.contrib.slack.utils import build_slack_message_document
slack_message = build_slack_message_document("document_delete", document)
except:
print "Could not build slack message for delete document."
document.delete()
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except:
print "Could not send slack message for delete document."
else:
document.delete()
return HttpResponseRedirect(reverse("document_browse"))
else:
return HttpResponse("Not allowed", status=403)
except PermissionDenied:
return HttpResponse(
'You are not allowed to delete this document',
mimetype="text/plain",
status=401
)
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_to_response(template,
RequestContext(request, {"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:
print "Could not build slack message for delete map."
delete_map.delay(object_id=map_obj.id)
# notify map owner that someone have deleted the map
if request.user != map_obj.owner:
recipient = map_obj.owner
notify.send(request.user,
recipient=recipient,
actor=request.user,
target=map_obj,
verb='deleted your map')
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except:
print "Could not send slack message for delete map."
else:
delete_map.delay(object_id=map_obj.id)
# notify map owner that someone have deleted the map
if request.user != map_obj.owner:
recipient = map_obj.owner
notify.send(request.user,
recipient=recipient,
actor=request.user,
target=map_obj,
verb='deleted your map')
return HttpResponseRedirect(reverse("maps_browse"))
def document_remove(request,
docid,
template='documents/document_remove.html',
basemodel=Document):
try:
document = _resolve_document(request,
docid,
'base.delete_resourcebase',
_PERMISSION_MSG_DELETE,
basemodel=basemodel)
if request.method == 'GET':
return render(request, template, context={"document": document})
if request.method == 'POST':
if getattr(settings, 'SLACK_ENABLED', False):
slack_message = None
try:
from geonode.contrib.slack.utils import build_slack_message_document
slack_message = build_slack_message_document(
"document_delete", document)
except BaseException:
print "Could not build slack message for delete document."
document.delete()
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except BaseException:
print "Could not send slack message for delete document."
else:
document.delete()
return HttpResponseRedirect(reverse(basemodel.namelc() +
"_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_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 layer_metadata(
request,
layername,
template='layers/layer_metadata.html',
ajax=True):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
layer_attribute_set = inlineformset_factory(
Layer,
Attribute,
extra=0,
form=LayerAttributeForm,
)
topic_category = layer.category
poc = layer.poc
metadata_author = layer.metadata_author
# 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.alternate,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
source_params=json.dumps(source_params))
else:
maplayer = GXPLayer(
name=layer.alternate,
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(request)[1] if la.ows_url is None]
if request.method == "POST":
if layer.metadata_uploaded_preserve: # layer metadata cannot be edited
out = {
'success': False,
'errors': METADATA_UPLOADED_PRESERVE_ERROR
}
return HttpResponse(
json.dumps(out),
content_type='application/json',
status=400)
layer_form = LayerForm(request.POST, instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
request.POST,
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(request.POST, prefix="category_choice_field", initial=int(
request.POST["category_choice_field"]) if "category_choice_field" in request.POST else None)
tkeywords_form = TKeywordForm(
request.POST,
prefix="tkeywords")
else:
layer_form = LayerForm(instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
# Keywords from THESAURI management
layer_tkeywords = layer.tkeywords.all()
tkeywords_list = ''
lang = 'en' # TODO: use user's language
if layer_tkeywords and len(layer_tkeywords) > 0:
tkeywords_ids = layer_tkeywords.values_list('id', flat=True)
if hasattr(settings, 'THESAURI'):
for el in settings.THESAURI:
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 BaseException:
tb = traceback.format_exc()
logger.error(tb)
tkeywords_form = TKeywordForm(
prefix="tkeywords",
initial={'tkeywords': tkeywords_list})
if request.method == "POST" and layer_form.is_valid() and attribute_form.is_valid(
) and category_form.is_valid() and tkeywords_form.is_valid():
new_poc = layer_form.cleaned_data['poc']
new_author = layer_form.cleaned_data['metadata_author']
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()
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
for form in attribute_form.cleaned_data:
la = Attribute.objects.get(id=int(form['id'].id))
la.description = form["description"]
la.attribute_label = form["attribute_label"]
la.visible = form["visible"]
la.display_order = form["display_order"]
la.save()
if new_poc is not None or new_author is not None:
if new_poc is not None:
layer.poc = new_poc
if new_author is not None:
layer.metadata_author = new_author
new_keywords = [x.strip() for x in layer_form.cleaned_data['keywords']]
if new_keywords is not None:
layer.keywords.clear()
layer.keywords.add(*new_keywords)
try:
the_layer = layer_form.save()
except BaseException:
tb = traceback.format_exc()
if tb:
logger.debug(tb)
the_layer = layer
up_sessions = UploadSession.objects.filter(layer=the_layer.id)
if up_sessions.count() > 0 and up_sessions[0].user != the_layer.owner:
up_sessions.update(user=the_layer.owner)
if new_category is not None:
Layer.objects.filter(id=the_layer.id).update(
category=new_category
)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(
build_slack_message_layer(
"layer_edit", the_layer))
except BaseException:
print "Could not send slack message."
if not ajax:
return HttpResponseRedirect(
reverse(
'layer_detail',
args=(
layer.service_typename,
)))
message = layer.alternate
try:
# Keywords from THESAURI management
tkeywords_to_add = []
tkeywords_cleaned = tkeywords_form.clean()
if tkeywords_cleaned and len(tkeywords_cleaned) > 0:
tkeywords_ids = []
for i, val in enumerate(tkeywords_cleaned):
try:
cleaned_data = [value for key, value in tkeywords_cleaned[i].items(
) if 'tkeywords-tkeywords' in key.lower() and 'autocomplete' not in key.lower()]
tkeywords_ids.extend(map(int, cleaned_data[0]))
except BaseException:
pass
if hasattr(settings, 'THESAURI'):
for el in settings.THESAURI:
thesaurus_name = el['name']
try:
t = Thesaurus.objects.get(
identifier=thesaurus_name)
for tk in t.thesaurus.all():
tkl = tk.keyword.filter(pk__in=tkeywords_ids)
if len(tkl) > 0:
tkeywords_to_add.append(tkl[0].keyword_id)
except BaseException:
tb = traceback.format_exc()
logger.error(tb)
layer.tkeywords.add(*tkeywords_to_add)
except BaseException:
tb = traceback.format_exc()
logger.error(tb)
return HttpResponse(json.dumps({'message': message}))
if settings.ADMIN_MODERATE_UPLOADS:
if not request.user.is_superuser:
layer_form.fields['is_published'].widget.attrs.update({'disabled': 'true'})
if not request.user.is_superuser and not request.user.is_staff:
can_change_metadata = request.user.has_perm(
'change_resourcebase_metadata',
layer.get_self_resource())
try:
is_manager = request.user.groupmember_set.all().filter(role='manager').exists()
except:
is_manager = False
if not is_manager or not can_change_metadata:
layer_form.fields['is_approved'].widget.attrs.update({'disabled': 'true'})
if poc is not None:
layer_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
else:
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = False
if metadata_author is not None:
layer_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
else:
author_form = ProfileForm(prefix="author")
author_form.hidden = False
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
u = uuid.uuid1()
access_token = u.hex
viewer = json.dumps(map_obj.viewer_json(
request.user, access_token, * (NON_WMS_BASE_LAYERS + [maplayer])))
metadataxsl = False
if "geonode.contrib.metadataxsl" in settings.INSTALLED_APPS:
metadataxsl = True
metadata_author_groups = []
if request.user.is_superuser or request.user.is_staff:
metadata_author_groups = GroupProfile.objects.all()
else:
all_metadata_author_groups = chain(
request.user.group_list_all().distinct(),
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]
return render_to_response(template, RequestContext(request, {
"resource": layer,
"layer": layer,
"layer_form": layer_form,
"poc_form": poc_form,
"author_form": author_form,
"attribute_form": attribute_form,
"category_form": category_form,
"tkeywords_form": tkeywords_form,
"viewer": viewer,
"preview": getattr(settings, 'LAYER_PREVIEW_LIBRARY', 'leaflet'),
"crs": getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'),
"metadataxsl": metadataxsl,
"freetext_readonly": getattr(
settings,
'FREETEXT_KEYWORDS_READONLY',
False),
"metadata_author_groups": metadata_author_groups,
"GROUP_MANDATORY_RESOURCES":
getattr(settings, 'GROUP_MANDATORY_RESOURCES', False),
}))
def map_metadata(request, mapid, template='maps/map_metadata.html', ajax=True):
map_obj = _resolve_map(request, mapid, 'base.change_resourcebase_metadata',
_PERMISSION_MSG_VIEW)
poc = map_obj.poc
metadata_author = map_obj.metadata_author
topic_category = map_obj.category
if request.method == "POST":
map_form = MapForm(request.POST, instance=map_obj, 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 else None)
else:
map_form = MapForm(instance=map_obj, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and map_form.is_valid(
) and category_form.is_valid():
new_poc = map_form.cleaned_data['poc']
new_author = map_form.cleaned_data['metadata_author']
new_keywords = map_form.cleaned_data['keywords']
new_regions = map_form.cleaned_data['regions']
new_title = strip_tags(map_form.cleaned_data['title'])
new_abstract = strip_tags(map_form.cleaned_data['abstract'])
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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.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.has_changed and author_form.is_valid():
new_author = author_form.save()
the_map = map_form.instance
if new_poc is not None and new_author is not None:
the_map.poc = new_poc
the_map.metadata_author = new_author
the_map.title = new_title
the_map.abstract = new_abstract
if new_keywords:
the_map.keywords.clear()
the_map.keywords.add(*new_keywords)
if new_regions:
the_map.regions.clear()
the_map.regions.add(*new_regions)
the_map.category = new_category
the_map.save()
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_map, send_slack_messages
send_slack_messages(
build_slack_message_map("map_edit", the_map))
except BaseException:
logger.error("Could not send slack message for modified map.")
if not ajax:
return HttpResponseRedirect(
reverse('map_detail', args=(map_obj.id, )))
message = map_obj.id
return HttpResponse(json.dumps({'message': message}))
# - POST Request Ends here -
# Request.GET
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
map_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(instance=metadata_author,
prefix="author")
else:
map_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
access_token = None
config = map_obj.viewer_json(request.user, access_token)
layers = MapLayer.objects.filter(map=map_obj.id)
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 BaseException:
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:
map_form.fields['is_published'].widget.attrs.update(
{'disabled': 'true'})
can_change_metadata = request.user.has_perm(
'change_resourcebase_metadata', map_obj.get_self_resource())
try:
is_manager = request.user.groupmember_set.all().filter(
role='manager').exists()
except BaseException:
is_manager = False
if not is_manager or not can_change_metadata:
map_form.fields['is_approved'].widget.attrs.update(
{'disabled': 'true'})
return render(request,
template,
context={
"config":
json.dumps(config),
"resource":
map_obj,
"map":
map_obj,
"map_form":
map_form,
"poc_form":
poc_form,
"author_form":
author_form,
"category_form":
category_form,
"layers":
layers,
"preview":
getattr(settings, 'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY',
'geoext'),
"crs":
getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:3857'),
"metadata_author_groups":
metadata_author_groups,
"GROUP_MANDATORY_RESOURCES":
getattr(settings, 'GROUP_MANDATORY_RESOURCES', False),
})
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 else None)
else:
document_form = DocumentForm(instance=document, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
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_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
if new_poc is None:
if poc.user 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()
# rename document file if any title fields changed
# TODO: in Geonode 2.8 there is separate 'version' field which in DRR used 'edition' field
title_fields = [
'category', 'regions', 'datasource', 'title', 'subtitle',
'papersize', 'date', 'version'
]
title_fields_changed = [
i for e in title_fields for i in document_form.changed_data
if e == i
]
if title_fields_changed:
doc_file_path = os.path.dirname(document.doc_file.name)
new_filename = '%s.%s' % (get_valid_filename('_'.join([
'afg', new_category.identifier, '-'.join([
r.code for r in Region.objects.all().filter(
pk__in=document_form.cleaned_data['regions'])
]), document_form.cleaned_data['datasource'],
slugify(document_form.cleaned_data['title'],
allow_unicode=True),
slugify(document_form.cleaned_data['subtitle'],
allow_unicode=True),
document_form.cleaned_data['papersize'],
document_form.cleaned_data['date'].strftime('%Y-%m-%d'),
document_form.cleaned_data['version']
])), document.extension)
new_doc_file = os.path.join(doc_file_path, new_filename)
old_path = os.path.join(settings.MEDIA_ROOT,
document.doc_file.name)
new_path = os.path.join(settings.MEDIA_ROOT, new_doc_file)
os.rename(old_path, new_path)
document.doc_file.name = new_doc_file
document.save()
the_document = document_form.instance
if new_poc is not None and new_author is not None:
the_document = document_form.save()
the_document.poc = new_poc
the_document.metadata_author = new_author
if new_keywords:
the_document.keywords.clear()
the_document.keywords.add(*new_keywords)
if new_regions:
the_document.regions.clear()
the_document.regions.add(*new_regions)
the_document.save()
document_form.save_many2many()
Document.objects.filter(id=the_document.id).update(
category=new_category)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_document, send_slack_messages
send_slack_messages(
build_slack_message_document("document_edit",
the_document))
except BaseException:
print "Could not send slack message for modified document."
if not ajax:
return HttpResponseRedirect(
reverse('document_detail', args=(document.id, )))
message = document.id
return HttpResponse(json.dumps({'message': message}))
# - POST Request Ends here -
# Request.GET
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
document_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(instance=metadata_author,
prefix="author")
else:
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 BaseException:
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 BaseException:
is_manager = False
if not is_manager or not can_change_metadata:
document_form.fields['is_approved'].widget.attrs.update(
{'disabled': 'true'})
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,
"metadata_author_groups":
metadata_author_groups,
"GROUP_MANDATORY_RESOURCES":
getattr(settings, 'GROUP_MANDATORY_RESOURCES',
False),
})
def layer_metadata(request, layername, template='layers/layer_metadata.html'):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
layer_attribute_set = inlineformset_factory(
Layer,
Attribute,
extra=0,
form=LayerAttributeForm,
)
topic_category = layer.category
poc = layer.poc
metadata_author = layer.metadata_author
if request.method == "POST":
layer_form = LayerForm(request.POST, instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
request.POST,
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
request.POST,
prefix="category_choice_field",
initial=int(
request.POST["category_choice_field"]) if "category_choice_field" in request.POST else None)
else:
layer_form = LayerForm(instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and layer_form.is_valid(
) and attribute_form.is_valid() and category_form.is_valid():
new_poc = layer_form.cleaned_data['poc']
new_author = layer_form.cleaned_data['metadata_author']
new_keywords = layer_form.cleaned_data['keywords']
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.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.has_changed and author_form.is_valid():
new_author = author_form.save()
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
for form in attribute_form.cleaned_data:
la = Attribute.objects.get(id=int(form['id'].id))
la.description = form["description"]
la.attribute_label = form["attribute_label"]
la.visible = form["visible"]
la.display_order = form["display_order"]
la.save()
if new_poc is not None and new_author is not None:
new_keywords = layer_form.cleaned_data['keywords']
layer.keywords.clear()
layer.keywords.add(*new_keywords)
the_layer = layer_form.save()
the_layer.poc = new_poc
the_layer.metadata_author = new_author
Layer.objects.filter(id=the_layer.id).update(
category=new_category
)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(build_slack_message_layer("layer_edit", the_layer))
except:
print "Could not send slack message."
return HttpResponseRedirect(
reverse(
'layer_detail',
args=(
layer.service_typename,
)))
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
layer_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(instance=metadata_author, prefix="author")
else:
layer_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
return render_to_response(template, RequestContext(request, {
"layer": layer,
"layer_form": layer_form,
"poc_form": poc_form,
"author_form": author_form,
"attribute_form": attribute_form,
"category_form": category_form,
}))
def document_metadata(
request,
docid,
template='documents/document_metadata.html'):
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', RequestContext(
request, {
})), status=404)
except PermissionDenied:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to edit this document.")})), 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 else None)
else:
document_form = DocumentForm(instance=document, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
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_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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()
if new_poc is not None and new_author is not None:
the_document = document_form.save()
the_document.poc = new_poc
the_document.metadata_author = new_author
the_document.keywords.add(*new_keywords)
Document.objects.filter(id=the_document.id).update(category=new_category)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_document, send_slack_messages
send_slack_messages(build_slack_message_document("document_edit", the_document))
except:
print "Could not send slack message for modified document."
return HttpResponseRedirect(
reverse(
'document_detail',
args=(
document.id,
)))
if poc is not None:
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
return render_to_response(template, RequestContext(request, {
"document": document,
"document_form": document_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
}))
def map_metadata(request, mapid, template="maps/cread_map_metadata.html"):
map_obj = _resolve_map(request, mapid, "base.change_resourcebase_metadata", _PERMISSION_MSG_VIEW)
cmapqs = CReadResource.objects.filter(resource=map_obj)
if len(cmapqs) == 0:
logger.info("cread_resource does not exist for map %r", map_obj)
cread_resource = None
else:
logger.debug("cread_resource found for map %r (%d)", map_obj, len(cmapqs))
cread_resource = cmapqs[0]
poc = map_obj.poc
metadata_author = map_obj.metadata_author
topic_category = map_obj.category
cread_subcategory = cread_resource.subcategory if cread_resource else None
if request.method == "POST":
baseinfo_form = CReadBaseInfoForm(request.POST, prefix="baseinfo")
map_form = CReadMapForm(
# map_form = MapForm(
request.POST,
instance=map_obj,
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 else None,
)
cread_subcategory_form = CReadSubCategoryForm(
request.POST,
prefix="cread_subcategory_choice_field",
initial=int(request.POST["cread_subcategory_choice_field"])
if "cread_subcategory_choice_field" in request.POST
else None,
)
else:
baseinfo_form = CReadBaseInfoForm(
prefix="baseinfo", initial={"title": map_obj.title, "abstract": map_obj.abstract}
)
map_form = CReadMapForm(instance=map_obj, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field", initial=topic_category.id if topic_category else None
)
cread_subcategory_form = CReadSubCategoryForm(
prefix="cread_subcategory_choice_field", initial=cread_subcategory.id if cread_subcategory else None
)
if (
request.method == "POST"
and baseinfo_form.is_valid()
and map_form.is_valid()
and cread_subcategory_form.is_valid()
):
new_title = strip_tags(baseinfo_form.cleaned_data["title"])
new_abstract = strip_tags(baseinfo_form.cleaned_data["abstract"])
new_poc = map_form.cleaned_data["poc"]
new_author = map_form.cleaned_data["metadata_author"]
new_keywords = map_form.cleaned_data["keywords"]
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.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.has_changed and author_form.is_valid():
new_author = author_form.save()
# CRead category
# note: call to is_valid is needed to compute the cleaned data
if cread_subcategory_form.is_valid():
logger.info("Checking CReadLayer record %r ", cread_subcategory_form.is_valid())
cread_subcat_id = cread_subcategory_form.cleaned_data["cread_subcategory_choice_field"]
new_creadsubcategory = CReadSubCategory.objects.get(id=cread_subcat_id)
new_creadcategory = new_creadsubcategory.category
logger.debug(
"Selected cread cat/subcat: %s : %s / %s",
new_creadcategory.identifier,
new_creadcategory.name,
new_creadsubcategory.identifier,
)
if cread_resource:
logger.info("Update CReadResource record")
else:
logger.info("Create new CReadResource record")
cread_resource = CReadResource()
cread_resource.resource = map_obj
cread_resource.category = new_creadcategory
cread_resource.subcategory = new_creadsubcategory
cread_resource.save()
else:
new_creadsubcategory = None
logger.info("CRead subcategory form is not valid")
# End cread category
# Update original topic category according to cread category
if category_form.is_valid():
new_category = TopicCategory.objects.get(id=category_form.cleaned_data["category_choice_field"])
elif new_creadsubcategory:
logger.debug("Assigning default ISO category from CREAD category")
new_category = TopicCategory.objects.get(id=new_creadsubcategory.relatedtopic.id)
if new_poc is not None and new_author is not None:
the_map = map_form.save()
the_map.poc = new_poc
the_map.metadata_author = new_author
the_map.title = new_title
the_map.abstract = new_abstract
the_map.save()
the_map.keywords.clear()
the_map.keywords.add(*new_keywords)
the_map.category = new_category
the_map.save()
if getattr(settings, "SLACK_ENABLED", False):
try:
from geonode.contrib.slack.utils import build_slack_message_map, send_slack_messages
send_slack_messages(build_slack_message_map("map_edit", the_map))
except:
print "Could not send slack message for modified map."
return HttpResponseRedirect(reverse("map_detail", args=(map_obj.id,)))
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
map_form.fields["poc"].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(instance=metadata_author, prefix="author")
else:
map_form.fields["metadata_author"].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
# creates cat - subcat association
categories_struct = []
for category in CReadCategory.objects.all():
subcats = []
for subcat in CReadSubCategory.objects.filter(category=category):
subcats.append(subcat.id)
categories_struct.append((category.id, category.description, subcats))
return render_to_response(
template,
RequestContext(
request,
{
"map": map_obj,
"map_form": map_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
"baseinfo_form": baseinfo_form,
"cread_sub_form": cread_subcategory_form,
"cread_categories": categories_struct,
},
),
)
def layer_metadata(request, layername, template='layers/layer_metadata.html'):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
layer_attribute_set = inlineformset_factory(
Layer,
Attribute,
extra=0,
form=LayerAttributeForm,
)
topic_category = layer.category
poc = layer.poc
metadata_author = layer.metadata_author
if request.method == "POST":
if layer.metadata_uploaded_preserve: # layer metadata cannot be edited
out = {
'success': False,
'errors': METADATA_UPLOADED_PRESERVE_ERROR
}
return HttpResponse(
json.dumps(out),
content_type='application/json',
status=400)
layer_form = LayerForm(request.POST, instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
request.POST,
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
request.POST,
prefix="category_choice_field",
initial=int(
request.POST["category_choice_field"]) if "category_choice_field" in request.POST else None)
else:
layer_form = LayerForm(instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and layer_form.is_valid(
) and attribute_form.is_valid() and category_form.is_valid():
new_poc = layer_form.cleaned_data['poc']
new_author = layer_form.cleaned_data['metadata_author']
new_keywords = layer_form.cleaned_data['keywords']
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()
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
for form in attribute_form.cleaned_data:
la = Attribute.objects.get(id=int(form['id'].id))
la.description = form["description"]
la.attribute_label = form["attribute_label"]
la.visible = form["visible"]
la.display_order = form["display_order"]
la.save()
if new_poc is not None and new_author is not None:
new_keywords = layer_form.cleaned_data['keywords']
layer.keywords.clear()
layer.keywords.add(*new_keywords)
the_layer = layer_form.save()
up_sessions = UploadSession.objects.filter(layer=the_layer.id)
if up_sessions.count() > 0 and up_sessions[0].user != the_layer.owner:
up_sessions.update(user=the_layer.owner)
the_layer.poc = new_poc
the_layer.metadata_author = new_author
Layer.objects.filter(id=the_layer.id).update(
category=new_category
)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(build_slack_message_layer("layer_edit", the_layer))
except:
print "Could not send slack message."
return HttpResponseRedirect(
reverse(
'layer_detail',
args=(
layer.service_typename,
)))
if poc is not None:
layer_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is not None:
layer_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
return render_to_response(template, RequestContext(request, {
"layer": layer,
"layer_form": layer_form,
"poc_form": poc_form,
"author_form": author_form,
"attribute_form": attribute_form,
"category_form": category_form,
}))
def map_metadata(request, mapid, template='maps/cread_map_metadata.html'):
map_obj = _resolve_map(request, mapid, 'base.change_resourcebase_metadata',
_PERMISSION_MSG_VIEW)
cmapqs = CReadResource.objects.filter(resource=map_obj)
if len(cmapqs) == 0:
logger.info('cread_resource does not exist for map %r', map_obj)
cread_resource = None
else:
logger.debug('cread_resource found for map %r (%d)', map_obj,
len(cmapqs))
cread_resource = cmapqs[0]
poc = map_obj.poc
metadata_author = map_obj.metadata_author
topic_category = map_obj.category
cread_subcategory = cread_resource.subcategory if cread_resource else None
if request.method == "POST":
baseinfo_form = CReadBaseInfoForm(request.POST, prefix="baseinfo")
map_form = CReadMapForm(
#map_form = MapForm(
request.POST,
instance=map_obj,
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 else None)
cread_subcategory_form = CReadSubCategoryForm(
request.POST,
prefix="cread_subcategory_choice_field",
initial=int(request.POST["cread_subcategory_choice_field"])
if "cread_subcategory_choice_field" in request.POST else None)
else:
baseinfo_form = CReadBaseInfoForm(prefix="baseinfo",
initial={
'title': map_obj.title,
'abstract': map_obj.abstract
})
map_form = CReadMapForm(instance=map_obj, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
cread_subcategory_form = CReadSubCategoryForm(
prefix="cread_subcategory_choice_field",
initial=cread_subcategory.id if cread_subcategory else None)
if request.method == "POST" \
and baseinfo_form.is_valid() \
and map_form.is_valid() \
and cread_subcategory_form.is_valid():
new_title = strip_tags(baseinfo_form.cleaned_data['title'])
new_abstract = strip_tags(baseinfo_form.cleaned_data['abstract'])
new_poc = map_form.cleaned_data['poc']
new_author = map_form.cleaned_data['metadata_author']
new_keywords = map_form.cleaned_data['keywords']
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.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.has_changed and author_form.is_valid():
new_author = author_form.save()
# CRead category
# note: call to is_valid is needed to compute the cleaned data
if (cread_subcategory_form.is_valid()):
logger.info("Checking CReadLayer record %r ",
cread_subcategory_form.is_valid())
cread_subcat_id = cread_subcategory_form.cleaned_data[
'cread_subcategory_choice_field']
new_creadsubcategory = CReadSubCategory.objects.get(
id=cread_subcat_id)
new_creadcategory = new_creadsubcategory.category
logger.debug("Selected cread cat/subcat: %s : %s / %s",
new_creadcategory.identifier, new_creadcategory.name,
new_creadsubcategory.identifier)
if cread_resource:
logger.info("Update CReadResource record")
else:
logger.info("Create new CReadResource record")
cread_resource = CReadResource()
cread_resource.resource = map_obj
cread_resource.category = new_creadcategory
cread_resource.subcategory = new_creadsubcategory
cread_resource.save()
else:
new_creadsubcategory = None
logger.info("CRead subcategory form is not valid")
# End cread category
# Update original topic category according to cread category
if category_form.is_valid():
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
elif new_creadsubcategory:
logger.debug("Assigning default ISO category from CREAD category")
new_category = TopicCategory.objects.get(
id=new_creadsubcategory.relatedtopic.id)
if new_poc is not None and new_author is not None:
the_map = map_form.save()
the_map.poc = new_poc
the_map.metadata_author = new_author
the_map.title = new_title
the_map.abstract = new_abstract
the_map.save()
the_map.keywords.clear()
the_map.keywords.add(*new_keywords)
the_map.category = new_category
the_map.save()
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_map, send_slack_messages
send_slack_messages(
build_slack_message_map("map_edit", the_map))
except:
print "Could not send slack message for modified map."
return HttpResponseRedirect(
reverse('map_detail', args=(map_obj.id, )))
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
map_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(instance=metadata_author,
prefix="author")
else:
map_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
# creates cat - subcat association
categories_struct = []
for category in CReadCategory.objects.all():
subcats = []
for subcat in CReadSubCategory.objects.filter(category=category):
subcats.append(subcat.id)
categories_struct.append((category.id, category.description, subcats))
return render_to_response(
template,
RequestContext(
request, {
"map": map_obj,
"map_form": map_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
"baseinfo_form": baseinfo_form,
"cread_sub_form": cread_subcategory_form,
"cread_categories": categories_struct
}))
def document_metadata(request,
docid,
template='documents/document_metadata.html'):
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', RequestContext(request, {})),
status=404)
except PermissionDenied:
return HttpResponse(loader.render_to_string(
'401.html',
RequestContext(request, {
'error_message':
_("You are not allowed to edit this document.")
})),
status=403)
if document is None:
return HttpResponse('An unknown error has occured.',
mimetype="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 else None)
else:
document_form = DocumentForm(instance=document, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
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_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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()
if new_poc is not None and new_author is not None:
the_document = document_form.save()
the_document.poc = new_poc
the_document.metadata_author = new_author
the_document.keywords.add(*new_keywords)
Document.objects.filter(id=the_document.id).update(
category=new_category)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_document, send_slack_messages
send_slack_messages(
build_slack_message_document(
"document_edit", the_document))
except:
print "Could not send slack message for modified document."
return HttpResponseRedirect(
reverse('document_detail', args=(document.id, )))
if poc is not None:
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
return render_to_response(
template,
RequestContext(
request, {
"document": document,
"document_form": document_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
}))
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 else None)
else:
document_form = DocumentForm(instance=document, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
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_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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()
the_document = document_form.instance
if new_poc is not None and new_author is not None:
the_document.poc = new_poc
the_document.metadata_author = new_author
if new_keywords:
the_document.keywords.clear()
the_document.keywords.add(*new_keywords)
if new_regions:
the_document.regions.clear()
the_document.regions.add(*new_regions)
the_document.save()
document_form.save_many2many()
Document.objects.filter(
id=the_document.id).update(
category=new_category)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_document, send_slack_messages
send_slack_messages(
build_slack_message_document(
"document_edit", the_document))
except BaseException:
print "Could not send slack message for modified document."
if not ajax:
return HttpResponseRedirect(
reverse(
'document_detail',
args=(
document.id,
)))
message = document.id
return HttpResponse(json.dumps({'message': message}))
# - POST Request Ends here -
# Request.GET
if poc is not None:
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 BaseException:
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 BaseException:
is_manager = False
if not is_manager or not can_change_metadata:
document_form.fields['is_approved'].widget.attrs.update(
{'disabled': 'true'})
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,
"metadata_author_groups": metadata_author_groups,
"GROUP_MANDATORY_RESOURCES": getattr(settings, 'GROUP_MANDATORY_RESOURCES', False),
})
def upload(incoming, user=None, overwrite=False,
name=None, title=None, abstract=None, date=None,
license=None,
category=None, keywords=None, regions=None,
skip=True, ignore_errors=True,
verbosity=1, console=None,
private=False, metadata_uploaded_preserve=False,
charset='UTF-8'):
"""Upload a directory of spatial data files to GeoNode
This function also verifies that each layer is in GeoServer.
Supported extensions are: .shp, .tif, .tar, .tar.gz, and .zip (of a shapefile).
It catches GeoNodeExceptions and gives a report per file
"""
if verbosity > 1:
print >> console, "Verifying that GeoNode is running ..."
if console is None:
console = open(os.devnull, 'w')
potential_files = []
if os.path.isfile(incoming):
___, short_filename = os.path.split(incoming)
basename, extension = os.path.splitext(short_filename)
filename = incoming
if extension in ['.tif', '.shp', '.tar', '.zip']:
potential_files.append((basename, filename))
elif short_filename.endswith('.tar.gz'):
potential_files.append((basename, filename))
elif not os.path.isdir(incoming):
msg = ('Please pass a filename or a directory name as the "incoming" '
'parameter, instead of %s: %s' % (incoming, type(incoming)))
logger.exception(msg)
raise GeoNodeException(msg)
else:
datadir = incoming
for root, dirs, files in os.walk(datadir):
for short_filename in files:
basename, extension = os.path.splitext(short_filename)
filename = os.path.join(root, short_filename)
if extension in ['.tif', '.shp', '.tar', '.zip']:
potential_files.append((basename, filename))
elif short_filename.endswith('.tar.gz'):
potential_files.append((basename, filename))
# After gathering the list of potential files,
# let's process them one by one.
number = len(potential_files)
if verbosity > 1:
msg = "Found %d potential layers." % number
print >> console, msg
if (number > 1) and (name is not None):
msg = 'Failed to process. Cannot specify name with multiple imports.'
raise Exception(msg)
output = []
for i, file_pair in enumerate(potential_files):
basename, filename = file_pair
existing_layers = Layer.objects.filter(name=basename)
if existing_layers.count() > 0:
existed = True
else:
existed = False
if existed and skip:
save_it = False
status = 'skipped'
layer = existing_layers[0]
if verbosity > 0:
msg = ('Stopping process because '
'--overwrite was not set '
'and a layer with this name already exists.')
print >> sys.stderr, msg
else:
save_it = True
if save_it:
try:
if is_zipfile(filename):
filename = unzip_file(filename)
if tarfile.is_tarfile(filename):
filename = extract_tarfile(filename)
layer = file_upload(
filename,
name=name,
title=title,
abstract=abstract,
date=date,
user=user,
overwrite=overwrite,
license=license,
category=category,
keywords=keywords,
regions=regions,
metadata_uploaded_preserve=metadata_uploaded_preserve,
charset=charset)
if not existed:
status = 'created'
else:
status = 'updated'
if private and user:
perm_spec = {
"users": {
"AnonymousUser": [],
user.username: [
"change_resourcebase_metadata",
"change_layer_data",
"change_layer_style",
"change_resourcebase",
"delete_resourcebase",
"change_resourcebase_permissions",
"publish_resourcebase"]},
"groups": {}}
layer.set_permissions(perm_spec)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(
build_slack_message_layer(
("layer_new" if status == "created" else "layer_edit"), layer))
except BaseException:
print "Could not send slack message."
except Exception as e:
if ignore_errors:
status = 'failed'
exception_type, error, traceback = sys.exc_info()
else:
if verbosity > 0:
msg = ('Stopping process because '
'--ignore-errors was not set '
'and an error was found.')
print >> sys.stderr, msg
msg = 'Failed to process %s' % filename
raise Exception(msg, e), None, sys.exc_info()[2]
msg = "[%s] Layer for '%s' (%d/%d)" % (status, filename, i + 1, number)
info = {'file': filename, 'status': status}
if status == 'failed':
info['traceback'] = traceback
info['exception_type'] = exception_type
info['error'] = error
else:
info['name'] = layer.name
output.append(info)
if verbosity > 0:
print >> console, msg
return output
def layer_metadata(request, layername, template='layers/layer_metadata.html'):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
layer_attribute_set = inlineformset_factory(
Layer,
Attribute,
extra=0,
form=LayerAttributeForm,
)
topic_category = layer.category
poc = layer.poc
metadata_author = layer.metadata_author
if request.method == "POST":
icraf_dr_category =Category.objects.get(pk=request.POST['icraf_dr_category']) #^^
icraf_dr_coverage =Coverage.objects.get(pk=request.POST['icraf_dr_coverage']) #^^
icraf_dr_source =Source.objects.get(pk=request.POST['icraf_dr_source']) #^^
icraf_dr_year =Year.objects.get(pk=request.POST['icraf_dr_year']) #^^
icraf_dr_date_created = request.POST['icraf_dr_date_created'] #^^
icraf_dr_date_published = request.POST['icraf_dr_date_published'] #^^
icraf_dr_date_revised = request.POST['icraf_dr_date_revised'] #^^
#^^ validate date format
if (len(icraf_dr_date_created)): #^^
try: #^^
parse(icraf_dr_date_created) #^^
except ValueError: #^^
icraf_dr_date_created = None #^^
else: #^^
icraf_dr_date_created = None #^^
if (len(icraf_dr_date_published)): #^^
try: #^^
parse(icraf_dr_date_published) #^^
except ValueError: #^^
icraf_dr_date_published = None #^^
else: #^^
icraf_dr_date_published = None #^^
if (len(icraf_dr_date_revised)): #^^
try: #^^
parse(icraf_dr_date_revised) #^^
except ValueError: #^^
icraf_dr_date_revised = None #^^
else: #^^
icraf_dr_date_revised = None #^^
try: #^^
main_topic_category = TopicCategory(id=request.POST['category_choice_field']) #^^
except: #^^
main_topic_category = None #^^
main_regions = ','.join(request.POST.getlist('resource-regions')) #^^ save as comma separated ids
main_defaults = { #^^
'category': icraf_dr_category, #^^
'coverage': icraf_dr_coverage, #^^
'source': icraf_dr_source, #^^
'year': icraf_dr_year, #^^
'topic_category': main_topic_category, #^^
'regions': main_regions, #^^
'date_created': icraf_dr_date_created, #^^
'date_published': icraf_dr_date_published, #^^
'date_revised': icraf_dr_date_revised #^^
} #^^
main, main_created = Main.objects.get_or_create(layer=layer, defaults=main_defaults) #^^
if not main_created: #^^
main.category = icraf_dr_category #^^
main.coverage = icraf_dr_coverage #^^
main.source = icraf_dr_source #^^
main.year = icraf_dr_year #^^
main.topic_category = main_topic_category #^^
main.regions = main_regions #^^
main.date_created = icraf_dr_date_created #^^
main.date_published = icraf_dr_date_published #^^
main.date_revised = icraf_dr_date_revised #^^
main.save() #^^
#^^ override resource-date with icraf_dr_date_created
#^^ override resource-edition with icraf_dr_year
request_post = request.POST.copy() #^^
request_post['resource-date'] = icraf_dr_date_created #^^
request_post['resource-edition'] = icraf_dr_year.year_num #^^
layer_form = LayerForm(request_post, instance=layer, prefix="resource") #^^ replace request.POST
attribute_form = layer_attribute_set(
request.POST,
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
request.POST,
prefix="category_choice_field",
initial=int(
request.POST["category_choice_field"]) if "category_choice_field" in request.POST else None)
else:
layer_form = LayerForm(instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
icraf_dr_categories = Category.objects.order_by('cat_num') #^^
icraf_dr_coverages = Coverage.objects.order_by('cov_num') #^^
icraf_dr_sources = Source.objects.order_by('src_num') #^^
icraf_dr_years = Year.objects.order_by('year_num') #^^
try: #^^
icraf_dr_main = Main.objects.get(layer=layer) #^^
except: #^^
icraf_dr_main = None #^^
if request.method == "POST" and layer_form.is_valid(
) and attribute_form.is_valid() and category_form.is_valid():
new_poc = layer_form.cleaned_data['poc']
new_author = layer_form.cleaned_data['metadata_author']
new_keywords = layer_form.cleaned_data['keywords']
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()
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
for form in attribute_form.cleaned_data:
la = Attribute.objects.get(id=int(form['id'].id))
la.description = form["description"]
la.attribute_label = form["attribute_label"]
la.visible = form["visible"]
la.display_order = form["display_order"]
la.save()
if new_poc is not None and new_author is not None:
new_keywords = layer_form.cleaned_data['keywords']
layer.keywords.clear()
layer.keywords.add(*new_keywords)
the_layer = layer_form.save()
the_layer.poc = new_poc
the_layer.metadata_author = new_author
Layer.objects.filter(id=the_layer.id).update(
category=new_category
)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(build_slack_message_layer("layer_edit", the_layer))
except:
print "Could not send slack message."
return HttpResponseRedirect(
reverse(
'layer_detail',
args=(
layer.service_typename,
)))
if poc is not None:
layer_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is not None:
layer_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
return render_to_response(template, RequestContext(request, {
"layer": layer,
"layer_form": layer_form,
"poc_form": poc_form,
"author_form": author_form,
"attribute_form": attribute_form,
"category_form": category_form,
'icraf_dr_categories': icraf_dr_categories, #^^
'icraf_dr_coverages': icraf_dr_coverages, #^^
'icraf_dr_sources': icraf_dr_sources, #^^
'icraf_dr_years': icraf_dr_years, #^^
'icraf_dr_main': icraf_dr_main, #^^
}))
def layer_metadata(request, layername, template='layers/layer_metadata.html'):
layer = _resolve_layer(request, layername,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
layer_attribute_set = inlineformset_factory(
Layer,
Attribute,
extra=0,
form=LayerAttributeForm,
)
topic_category = layer.category
poc = layer.poc
metadata_author = layer.metadata_author
if request.method == "POST":
if layer.metadata_uploaded_preserve: # layer metadata cannot be edited
out = {
'success': False,
'errors': METADATA_UPLOADED_PRESERVE_ERROR
}
return HttpResponse(json.dumps(out),
content_type='application/json',
status=400)
layer_form = LayerForm(request.POST, instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
request.POST,
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
request.POST,
prefix="category_choice_field",
initial=int(request.POST["category_choice_field"])
if "category_choice_field" in request.POST else None)
else:
layer_form = LayerForm(instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and layer_form.is_valid(
) and attribute_form.is_valid() and category_form.is_valid():
new_poc = layer_form.cleaned_data['poc']
new_author = layer_form.cleaned_data['metadata_author']
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()
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
for form in attribute_form.cleaned_data:
la = Attribute.objects.get(id=int(form['id'].id))
la.description = form["description"]
la.attribute_label = form["attribute_label"]
la.visible = form["visible"]
la.display_order = form["display_order"]
la.save()
if new_poc is not None and new_author is not None:
new_keywords = [
x.strip() for x in layer_form.cleaned_data['keywords']
]
layer.keywords.clear()
layer.keywords.add(*new_keywords)
the_layer = layer_form.save()
up_sessions = UploadSession.objects.filter(layer=the_layer.id)
if up_sessions.count(
) > 0 and up_sessions[0].user != the_layer.owner:
up_sessions.update(user=the_layer.owner)
the_layer.poc = new_poc
the_layer.metadata_author = new_author
Layer.objects.filter(id=the_layer.id).update(category=new_category)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(
build_slack_message_layer("layer_edit", the_layer))
except:
print "Could not send slack message."
return HttpResponseRedirect(
reverse('layer_detail', args=(layer.service_typename, )))
if poc is not None:
layer_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
else:
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = False
if metadata_author is not None:
layer_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
else:
author_form = ProfileForm(prefix="author")
author_form.hidden = False
return render_to_response(
template,
RequestContext(
request, {
"layer": layer,
"layer_form": layer_form,
"poc_form": poc_form,
"author_form": author_form,
"attribute_form": attribute_form,
"category_form": category_form,
}))
def map_metadata(
request,
mapid,
template='maps/map_metadata.html',
ajax=True):
map_obj = _resolve_map(
request,
mapid,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_VIEW)
poc = map_obj.poc
metadata_author = map_obj.metadata_author
topic_category = map_obj.category
if request.method == "POST":
map_form = MapForm(request.POST, instance=map_obj, 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 else None)
else:
map_form = MapForm(instance=map_obj, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and map_form.is_valid(
) and category_form.is_valid():
new_poc = map_form.cleaned_data['poc']
new_author = map_form.cleaned_data['metadata_author']
new_keywords = map_form.cleaned_data['keywords']
new_regions = map_form.cleaned_data['regions']
new_title = strip_tags(map_form.cleaned_data['title'])
new_abstract = strip_tags(map_form.cleaned_data['abstract'])
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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.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.has_changed and author_form.is_valid():
new_author = author_form.save()
the_map = map_form.instance
if new_poc is not None and new_author is not None:
the_map.poc = new_poc
the_map.metadata_author = new_author
the_map.title = new_title
the_map.abstract = new_abstract
if new_keywords:
the_map.keywords.clear()
the_map.keywords.add(*new_keywords)
if new_regions:
the_map.regions.clear()
the_map.regions.add(*new_regions)
the_map.category = new_category
the_map.save()
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_map, send_slack_messages
send_slack_messages(
build_slack_message_map(
"map_edit", the_map))
except BaseException:
logger.error("Could not send slack message for modified map.")
if not ajax:
return HttpResponseRedirect(
reverse(
'map_detail',
args=(
map_obj.id,
)))
message = map_obj.id
return HttpResponse(json.dumps({'message': message}))
# - POST Request Ends here -
# Request.GET
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
map_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(
instance=metadata_author,
prefix="author")
else:
map_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
config = map_obj.viewer_json(request)
layers = MapLayer.objects.filter(map=map_obj.id)
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 BaseException:
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:
map_form.fields['is_published'].widget.attrs.update(
{'disabled': 'true'})
can_change_metadata = request.user.has_perm(
'change_resourcebase_metadata',
map_obj.get_self_resource())
try:
is_manager = request.user.groupmember_set.all().filter(role='manager').exists()
except BaseException:
is_manager = False
if not is_manager or not can_change_metadata:
map_form.fields['is_approved'].widget.attrs.update(
{'disabled': 'true'})
return render(request, template, context={
"config": json.dumps(config),
"resource": map_obj,
"map": map_obj,
"map_form": map_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
"layers": layers,
"preview": getattr(settings, 'GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY', 'geoext'),
"crs": getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:3857'),
"metadata_author_groups": metadata_author_groups,
"GROUP_MANDATORY_RESOURCES": getattr(settings, 'GROUP_MANDATORY_RESOURCES', False),
})
def map_metadata(request, mapid, template='maps/map_metadata.html'):
map_obj = _resolve_map(request, mapid, 'base.change_resourcebase_metadata', _PERMISSION_MSG_VIEW)
poc = map_obj.poc
metadata_author = map_obj.metadata_author
topic_category = map_obj.category
if request.method == "POST":
map_form = MapForm(request.POST, instance=map_obj, 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 else None)
else:
map_form = MapForm(instance=map_obj, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and map_form.is_valid(
) and category_form.is_valid():
new_poc = map_form.cleaned_data['poc']
new_author = map_form.cleaned_data['metadata_author']
new_keywords = map_form.cleaned_data['keywords']
new_title = strip_tags(map_form.cleaned_data['title'])
new_abstract = strip_tags(map_form.cleaned_data['abstract'])
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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.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.has_changed and author_form.is_valid():
new_author = author_form.save()
if new_poc is not None and new_author is not None:
the_map = map_form.save()
the_map.poc = new_poc
the_map.metadata_author = new_author
the_map.title = new_title
the_map.abstract = new_abstract
the_map.save()
the_map.keywords.clear()
the_map.keywords.add(*new_keywords)
the_map.category = new_category
the_map.save()
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_map, send_slack_messages
send_slack_messages(build_slack_message_map("map_edit", the_map))
except:
print "Could not send slack message for modified map."
return HttpResponseRedirect(
reverse(
'map_detail',
args=(
map_obj.id,
)))
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
map_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(
instance=metadata_author,
prefix="author")
else:
map_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
return render_to_response(template, RequestContext(request, {
"map": map_obj,
"map_form": map_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
}))
def map_metadata(request, mapid, template='maps/map_metadata.html'):
map_obj = _resolve_map(request, mapid, 'base.change_resourcebase_metadata',
_PERMISSION_MSG_VIEW)
poc = map_obj.poc
metadata_author = map_obj.metadata_author
topic_category = map_obj.category
if request.method == "POST":
map_form = MapForm(request.POST, instance=map_obj, 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 else None)
else:
map_form = MapForm(instance=map_obj, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and map_form.is_valid(
) and category_form.is_valid():
new_poc = map_form.cleaned_data['poc']
new_author = map_form.cleaned_data['metadata_author']
new_keywords = map_form.cleaned_data['keywords']
new_title = strip_tags(map_form.cleaned_data['title'])
new_abstract = strip_tags(map_form.cleaned_data['abstract'])
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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.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.has_changed and author_form.is_valid():
new_author = author_form.save()
if new_poc is not None and new_author is not None:
the_map = map_form.save()
the_map.poc = new_poc
the_map.metadata_author = new_author
the_map.title = new_title
the_map.abstract = new_abstract
the_map.save()
the_map.keywords.clear()
the_map.keywords.add(*new_keywords)
the_map.category = new_category
the_map.save()
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_map, send_slack_messages
send_slack_messages(
build_slack_message_map("map_edit", the_map))
except:
print "Could not send slack message for modified map."
return HttpResponseRedirect(
reverse('map_detail', args=(map_obj.id, )))
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
map_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(instance=metadata_author,
prefix="author")
else:
map_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
access_token = None
config = map_obj.viewer_json(request.user, access_token)
layers = MapLayer.objects.filter(map=map_obj.id)
metadata_author_groups = []
if request.user.is_superuser:
metadata_author_groups = GroupProfile.objects.all()
else:
metadata_author_groups = metadata_author.group_list_all()
return render_to_response(
template,
RequestContext(
request, {
"config": json.dumps(config),
"map": map_obj,
"map_form": map_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
"layers": layers,
"preview": getattr(settings, 'LAYER_PREVIEW_LIBRARY',
'leaflet'),
"crs": getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'),
"metadata_author_groups": metadata_author_groups,
}))
def layer_metadata(request, layername, template='layers/layer_metadata.html', ajax=True):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase_metadata',
_PERMISSION_MSG_METADATA)
layer_attribute_set = inlineformset_factory(
Layer,
Attribute,
extra=0,
form=LayerAttributeForm,
)
topic_category = layer.category
poc = layer.poc
metadata_author = layer.metadata_author
# 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(request)[1] if la.ows_url is None]
if request.method == "POST":
if layer.metadata_uploaded_preserve: # layer metadata cannot be edited
out = {
'success': False,
'errors': METADATA_UPLOADED_PRESERVE_ERROR
}
return HttpResponse(
json.dumps(out),
content_type='application/json',
status=400)
layer_form = LayerForm(request.POST, instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
request.POST,
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
request.POST,
prefix="category_choice_field",
initial=int(
request.POST["category_choice_field"]) if "category_choice_field" in request.POST else None)
tkeywords_form = TKeywordForm(
request.POST,
prefix="tkeywords")
else:
layer_form = LayerForm(instance=layer, prefix="resource")
attribute_form = layer_attribute_set(
instance=layer,
prefix="layer_attribute_set",
queryset=Attribute.objects.order_by('display_order'))
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
# Keywords from THESAURI management
layer_tkeywords = layer.tkeywords.all()
tkeywords_list = ''
lang = 'en' # TODO: use user's language
if layer_tkeywords and len(layer_tkeywords) > 0:
tkeywords_ids = layer_tkeywords.values_list('id', flat=True)
if hasattr(settings, 'THESAURI'):
for el in settings.THESAURI:
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:
tb = traceback.format_exc()
logger.error(tb)
tkeywords_form = TKeywordForm(
prefix="tkeywords",
initial={'tkeywords': tkeywords_list})
if request.method == "POST" and layer_form.is_valid(
) and attribute_form.is_valid() and category_form.is_valid() and tkeywords_form.is_valid():
new_poc = layer_form.cleaned_data['poc']
new_author = layer_form.cleaned_data['metadata_author']
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()
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
for form in attribute_form.cleaned_data:
la = Attribute.objects.get(id=int(form['id'].id))
la.description = form["description"]
la.attribute_label = form["attribute_label"]
la.visible = form["visible"]
la.display_order = form["display_order"]
la.save()
if new_poc is not None and new_author is not None:
# layer.poc = new_poc
# layer.metadata_author = new_author
new_keywords = [x.strip() for x in layer_form.cleaned_data['keywords']]
layer.keywords.clear()
layer.keywords.add(*new_keywords)
try:
the_layer = layer_form.save()
except:
tb = traceback.format_exc()
if tb:
logger.debug(tb)
the_layer = layer
up_sessions = UploadSession.objects.filter(layer=the_layer.id)
if up_sessions.count() > 0 and up_sessions[0].user != the_layer.owner:
up_sessions.update(user=the_layer.owner)
Layer.objects.filter(id=the_layer.id).update(
category=new_category
)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(build_slack_message_layer("layer_edit", the_layer))
except:
print "Could not send slack message."
if not ajax:
return HttpResponseRedirect(
reverse(
'layer_detail',
args=(
layer.service_typename,
)))
message = layer.typename
try:
# Keywords from THESAURI management
tkeywords_to_add = []
tkeywords_cleaned = tkeywords_form.clean()
if tkeywords_cleaned and len(tkeywords_cleaned) > 0:
tkeywords_ids = []
for i, val in enumerate(tkeywords_cleaned):
try:
cleaned_data = [value for key, value
in tkeywords_cleaned[i].items()
if 'tkeywords-tkeywords' in key.lower() and 'autocomplete' not in key.lower()]
tkeywords_ids.extend(map(int, cleaned_data[0]))
except:
pass
if hasattr(settings, 'THESAURI'):
for el in settings.THESAURI:
thesaurus_name = el['name']
try:
t = Thesaurus.objects.get(identifier=thesaurus_name)
for tk in t.thesaurus.all():
tkl = tk.keyword.filter(pk__in=tkeywords_ids)
if len(tkl) > 0:
tkeywords_to_add.append(tkl[0].keyword_id)
except:
tb = traceback.format_exc()
logger.error(tb)
layer.tkeywords.add(*tkeywords_to_add)
except:
tb = traceback.format_exc()
logger.error(tb)
return HttpResponse(json.dumps({'message': message}))
if poc is not None:
layer_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
else:
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = False
if metadata_author is not None:
layer_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
else:
author_form = ProfileForm(prefix="author")
author_form.hidden = False
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
u = uuid.uuid1()
access_token = u.hex
viewer = json.dumps(
map_obj.viewer_json(request.user, access_token, * (NON_WMS_BASE_LAYERS + [maplayer])))
metadataxsl = False
if "geonode.contrib.metadataxsl" in settings.INSTALLED_APPS:
metadataxsl = True
return render_to_response(template, RequestContext(request, {
"resource": layer,
"layer": layer,
"layer_form": layer_form,
"poc_form": poc_form,
"author_form": author_form,
"attribute_form": attribute_form,
"category_form": category_form,
"tkeywords_form": tkeywords_form,
"viewer": viewer,
"preview": getattr(settings, 'LAYER_PREVIEW_LIBRARY', 'leaflet'),
"crs": getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'),
"metadataxsl": metadataxsl
}))
def map_metadata(request, mapid, template='maps/map_metadata.html'):
map_obj = _resolve_map(request, mapid, 'base.change_resourcebase_metadata',
_PERMISSION_MSG_VIEW)
poc = map_obj.poc
metadata_author = map_obj.metadata_author
topic_category = map_obj.category
if request.method == "POST":
map_form = MapForm(request.POST, instance=map_obj, 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 else None)
else:
map_form = MapForm(instance=map_obj, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and map_form.is_valid(
) and category_form.is_valid():
new_poc = map_form.cleaned_data['poc']
new_author = map_form.cleaned_data['metadata_author']
new_keywords = map_form.cleaned_data['keywords']
new_title = strip_tags(map_form.cleaned_data['title'])
new_abstract = strip_tags(map_form.cleaned_data['abstract'])
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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.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.has_changed and author_form.is_valid():
new_author = author_form.save()
if new_poc is not None and new_author is not None:
the_map = map_form.save()
the_map.poc = new_poc
the_map.metadata_author = new_author
the_map.title = new_title
the_map.abstract = new_abstract
the_map.save()
the_map.keywords.clear()
the_map.keywords.add(*new_keywords)
the_map.category = new_category
the_map.save()
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_map, send_slack_messages
send_slack_messages(
build_slack_message_map("map_edit", the_map))
except:
print "Could not send slack message for modified map."
return HttpResponseRedirect(
reverse('map_detail', args=(map_obj.id, )))
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
map_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(instance=metadata_author,
prefix="author")
else:
map_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
return render_to_response(
template,
RequestContext(
request, {
"map": map_obj,
"map_form": map_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
}))
def document_metadata(
request,
docid,
template='documents/document_metadata.html'):
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', RequestContext(
request, {
})), status=404)
except PermissionDenied:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to edit this document.")})), status=403)
if document is None:
return HttpResponse(
'An unknown error has occured.',
mimetype="text/plain",
status=401
)
else:
poc = document.poc
metadata_author = document.metadata_author
topic_category = document.category
if request.method == "POST":
icraf_dr_category =Category.objects.get(pk=request.POST['icraf_dr_category']) #^^
icraf_dr_coverage =Coverage.objects.get(pk=request.POST['icraf_dr_coverage']) #^^
icraf_dr_source =Source.objects.get(pk=request.POST['icraf_dr_source']) #^^
icraf_dr_year =Year.objects.get(pk=request.POST['icraf_dr_year']) #^^
icraf_dr_date_created = request.POST['icraf_dr_date_created'] #^^
icraf_dr_date_published = request.POST['icraf_dr_date_published'] #^^
icraf_dr_date_revised = request.POST['icraf_dr_date_revised'] #^^
#^^ validate date format
if (len(icraf_dr_date_created)): #^^
try: #^^
parse(icraf_dr_date_created) #^^
except ValueError: #^^
icraf_dr_date_created = None #^^
else: #^^
icraf_dr_date_created = None #^^
if (len(icraf_dr_date_published)): #^^
try: #^^
parse(icraf_dr_date_published) #^^
except ValueError: #^^
icraf_dr_date_published = None #^^
else: #^^
icraf_dr_date_published = None #^^
if (len(icraf_dr_date_revised)): #^^
try: #^^
parse(icraf_dr_date_revised) #^^
except ValueError: #^^
icraf_dr_date_revised = None #^^
else: #^^
icraf_dr_date_revised = None #^^
try: #^^
main_topic_category = TopicCategory(id=request.POST['category_choice_field']) #^^
except: #^^
main_topic_category = None #^^
main_regions = ','.join(request.POST.getlist('resource-regions')) #^^ save as comma separated ids
main_defaults = { #^^
'category': icraf_dr_category, #^^
'coverage': icraf_dr_coverage, #^^
'source': icraf_dr_source, #^^
'year': icraf_dr_year, #^^
'topic_category': main_topic_category, #^^
'regions': main_regions, #^^
#^^ 'date_created': icraf_dr_date_created, #^^ 20151019 label swapped!
#^^ 'date_published': icraf_dr_date_published, #^^ 20151019 label swapped!
'date_created': icraf_dr_date_published, #^^
'date_published': icraf_dr_date_created, #^^
'date_revised': icraf_dr_date_revised #^^
} #^^
main, main_created = Main.objects.get_or_create(document=document, defaults=main_defaults) #^^
if not main_created: #^^
main.category = icraf_dr_category #^^
main.coverage = icraf_dr_coverage #^^
main.source = icraf_dr_source #^^
main.year = icraf_dr_year #^^
main.topic_category = main_topic_category #^^
main.regions = main_regions #^^
#^^ main.date_created = icraf_dr_date_created #^^ 20151019 label swapped!
#^^ main.date_published = icraf_dr_date_published #^^ 20151019 label swapped!
main.date_created = icraf_dr_date_published #^^
main.date_published = icraf_dr_date_created #^^
main.date_revised = icraf_dr_date_revised #^^
main.save() #^^
#^^ override resource-date with icraf_dr_date_created
#^^ override resource-edition with icraf_dr_year
request_post = request.POST.copy() #^^
request_post['resource-date'] = icraf_dr_date_created #^^
request_post['resource-edition'] = icraf_dr_year.year_num #^^
document_form = DocumentForm(
request_post, #^^ replace 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 else None)
else:
document_form = DocumentForm(instance=document, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
icraf_dr_categories = Category.objects.order_by('cat_num') #^^
icraf_dr_coverages = Coverage.objects.order_by('cov_num') #^^
icraf_dr_sources = Source.objects.order_by('src_num') #^^
icraf_dr_years = Year.objects.order_by('year_num') #^^
try: #^^
icraf_dr_main = Main.objects.get(document=document) #^^
except: #^^
icraf_dr_main = None #^^
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_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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()
if new_poc is not None and new_author is not None:
the_document = document_form.save()
the_document.poc = new_poc
the_document.metadata_author = new_author
the_document.keywords.add(*new_keywords)
Document.objects.filter(id=the_document.id).update(category=new_category)
#^^ start update doc_type
doc_type = request.POST.get('doc_type', None) #^^
if doc_type:
try:
Document.objects.filter(id=the_document.id).update(doc_type=doc_type)
except:
pass
#^^ end
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_document, send_slack_messages
send_slack_messages(build_slack_message_document("document_edit", the_document))
except:
print "Could not send slack message for modified document."
return HttpResponseRedirect(
reverse(
'document_detail',
args=(
document.id,
)))
if poc is not None:
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
return render_to_response(template, RequestContext(request, {
"document": document,
"document_form": document_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
'icraf_dr_categories': icraf_dr_categories, #^^
'icraf_dr_coverages': icraf_dr_coverages, #^^
'icraf_dr_sources': icraf_dr_sources, #^^
'icraf_dr_years': icraf_dr_years, #^^
'icraf_dr_main': icraf_dr_main, #^^
}))
def upload(incoming, user=None, overwrite=False,
name=None, title=None, abstract=None, date=None,
license=None,
category=None, keywords=None, regions=None,
skip=True, ignore_errors=True,
verbosity=1, console=None,
private=False, metadata_uploaded_preserve=False,
charset='UTF-8'):
"""Upload a directory of spatial data files to GeoNode
This function also verifies that each layer is in GeoServer.
Supported extensions are: .shp, .tif, .tar, .tar.gz, and .zip (of a shapefile).
It catches GeoNodeExceptions and gives a report per file
"""
if verbosity > 1:
print >> console, "Verifying that GeoNode is running ..."
if console is None:
console = open(os.devnull, 'w')
potential_files = []
if os.path.isfile(incoming):
___, short_filename = os.path.split(incoming)
basename, extension = os.path.splitext(short_filename)
filename = incoming
if extension in ['.tif', '.shp', '.tar', '.zip']:
potential_files.append((basename, filename))
elif short_filename.endswith('.tar.gz'):
potential_files.append((basename, filename))
elif not os.path.isdir(incoming):
msg = ('Please pass a filename or a directory name as the "incoming" '
'parameter, instead of %s: %s' % (incoming, type(incoming)))
logger.exception(msg)
raise GeoNodeException(msg)
else:
datadir = incoming
for root, dirs, files in os.walk(datadir):
for short_filename in files:
basename, extension = os.path.splitext(short_filename)
filename = os.path.join(root, short_filename)
if extension in ['.tif', '.shp', '.tar', '.zip']:
potential_files.append((basename, filename))
elif short_filename.endswith('.tar.gz'):
potential_files.append((basename, filename))
# After gathering the list of potential files,
# let's process them one by one.
number = len(potential_files)
if verbosity > 1:
msg = "Found %d potential layers." % number
print >> console, msg
if (number > 1) and (name is not None):
msg = 'Failed to process. Cannot specify name with multiple imports.'
raise Exception(msg)
output = []
for i, file_pair in enumerate(potential_files):
basename, filename = file_pair
existing_layers = Layer.objects.filter(name=basename)
if existing_layers.count() > 0:
existed = True
else:
existed = False
if existed and skip:
save_it = False
status = 'skipped'
layer = existing_layers[0]
if verbosity > 0:
msg = ('Stopping process because '
'--overwrite was not set '
'and a layer with this name already exists.')
print >> sys.stderr, msg
else:
save_it = True
if save_it:
try:
if is_zipfile(filename):
filename = unzip_file(filename)
if tarfile.is_tarfile(filename):
filename = extract_tarfile(filename)
layer = file_upload(
filename,
name=name,
title=title,
abstract=abstract,
date=date,
user=user,
overwrite=overwrite,
license=license,
category=category,
keywords=keywords,
regions=regions,
metadata_uploaded_preserve=metadata_uploaded_preserve,
charset=charset)
if not existed:
status = 'created'
else:
status = 'updated'
if private and user:
perm_spec = {
"users": {
"AnonymousUser": [],
user.username: [
"change_resourcebase_metadata",
"change_layer_data",
"change_layer_style",
"change_resourcebase",
"delete_resourcebase",
"change_resourcebase_permissions",
"publish_resourcebase"]},
"groups": {}}
layer.set_permissions(perm_spec)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_layer, send_slack_messages
send_slack_messages(
build_slack_message_layer(
("layer_new" if status == "created" else "layer_edit"), layer))
except BaseException:
logger.error("Could not send slack message.")
except Exception as e:
if ignore_errors:
status = 'failed'
exception_type, error, traceback = sys.exc_info()
else:
if verbosity > 0:
msg = ('Stopping process because '
'--ignore-errors was not set '
'and an error was found.')
print >> sys.stderr, msg
msg = 'Failed to process %s' % filename
raise Exception(msg, e), None, sys.exc_info()[2]
msg = "[%s] Layer for '%s' (%d/%d)" % (status, filename, i + 1, number)
info = {'file': filename, 'status': status}
if status == 'failed':
info['traceback'] = traceback
info['exception_type'] = exception_type
info['error'] = error
else:
info['name'] = layer.name
output.append(info)
if verbosity > 0:
print >> console, msg
return output
def document_metadata(request,
docid,
template='documents/document_metadata.html'):
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', RequestContext(request, {})),
status=404)
except PermissionDenied:
return HttpResponse(loader.render_to_string(
'401.html',
RequestContext(request, {
'error_message':
_("You are not allowed to edit this document.")
})),
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 else None)
else:
document_form = DocumentForm(instance=document, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
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_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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()
the_document = document_form.instance
if new_poc is not None and new_author is not None:
the_document.poc = new_poc
the_document.metadata_author = new_author
if new_keywords:
the_document.keywords.clear()
the_document.keywords.add(*new_keywords)
if new_regions:
the_document.regions.clear()
the_document.regions.add(*new_regions)
the_document.save()
document_form.save_many2many()
Document.objects.filter(id=the_document.id).update(
category=new_category)
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_document, send_slack_messages
send_slack_messages(
build_slack_message_document("document_edit",
the_document))
except BaseException:
print "Could not send slack message for modified document."
return HttpResponseRedirect(
reverse('document_detail', args=(document.id, )))
# - POST Request Ends here -
# Request.GET
if poc is not None:
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:
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:
is_manager = False
if not is_manager or not can_change_metadata:
document_form.fields['is_approved'].widget.attrs.update(
{'disabled': 'true'})
return render_to_response(
template,
RequestContext(
request, {
"resource":
document,
"document":
document,
"document_form":
document_form,
"poc_form":
poc_form,
"author_form":
author_form,
"category_form":
category_form,
"metadata_author_groups":
metadata_author_groups,
"GROUP_MANDATORY_RESOURCES":
getattr(settings, 'GROUP_MANDATORY_RESOURCES', False),
}))
def map_metadata(request, mapid, template='maps/map_metadata.html'):
map_obj = _resolve_map(request, mapid, 'base.change_resourcebase_metadata', _PERMISSION_MSG_VIEW)
poc = map_obj.poc
metadata_author = map_obj.metadata_author
topic_category = map_obj.category
if request.method == "POST":
map_form = MapForm(request.POST, instance=map_obj, 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 else None)
else:
map_form = MapForm(instance=map_obj, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field",
initial=topic_category.id if topic_category else None)
if request.method == "POST" and map_form.is_valid(
) and category_form.is_valid():
new_poc = map_form.cleaned_data['poc']
new_author = map_form.cleaned_data['metadata_author']
new_keywords = map_form.cleaned_data['keywords']
new_title = strip_tags(map_form.cleaned_data['title'])
new_abstract = strip_tags(map_form.cleaned_data['abstract'])
new_category = TopicCategory.objects.get(
id=category_form.cleaned_data['category_choice_field'])
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.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.has_changed and author_form.is_valid():
new_author = author_form.save()
if new_poc is not None and new_author is not None:
the_map = map_form.save()
the_map.poc = new_poc
the_map.metadata_author = new_author
the_map.title = new_title
the_map.abstract = new_abstract
the_map.save()
the_map.keywords.clear()
the_map.keywords.add(*new_keywords)
the_map.category = new_category
the_map.save()
if getattr(settings, 'SLACK_ENABLED', False):
try:
from geonode.contrib.slack.utils import build_slack_message_map, send_slack_messages
send_slack_messages(build_slack_message_map("map_edit", the_map))
except:
print "Could not send slack message for modified map."
return HttpResponseRedirect(
reverse(
'map_detail',
args=(
map_obj.id,
)))
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
map_form.fields['poc'].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(
instance=metadata_author,
prefix="author")
else:
map_form.fields['metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
if 'access_token' in request.session:
access_token = request.session['access_token']
else:
access_token = None
config = map_obj.viewer_json(request.user, access_token)
layers = MapLayer.objects.filter(map=map_obj.id)
metadata_author_groups = []
if request.user.is_superuser:
metadata_author_groups = GroupProfile.objects.all()
else:
metadata_author_groups = metadata_author.group_list_all()
return render_to_response(template, RequestContext(request, {
"config": json.dumps(config),
"map": map_obj,
"map_form": map_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
"layers": layers,
"preview": getattr(settings, 'LAYER_PREVIEW_LIBRARY', 'leaflet'),
"crs": getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'),
"metadata_author_groups": metadata_author_groups,
}))
