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, }))