Beispiel #1
0
def add_main(request, template='icraf_dr/add_main.html'):
    context = RequestContext(request)
    
    if request.method == 'POST':
        form = MainForm(request.POST, request.FILES)
        
        if form.is_valid():
            # saving manually
            main = Main(
                category=Category.objects.get(pk=request.POST['category']),
                coverage=Coverage.objects.get(pk=request.POST['coverage']),
                source=Source.objects.get(pk=request.POST['source']),
                year=Year.objects.get(pk=request.POST['year']),
                basename=request.POST['basename']
            )
            
            main.save()
            
            #form.save(commit=True)
            
            return HttpResponseRedirect(reverse('icraf_dr_index'))
        else:
            print form.errors
    else:
        form = MainForm()
    
    return render_to_response(template, {'form': form}, context)
    def form_valid(self, form):
        """
        If the form is valid, save the associated model.
        """
        print 'debug document form valid' #^^
        
        icraf_dr_category =Category.objects.get(pk=self.request.POST['icraf_dr_category']) #^^
        icraf_dr_coverage =Coverage.objects.get(pk=self.request.POST['icraf_dr_coverage']) #^^
        icraf_dr_source =Source.objects.get(pk=self.request.POST['icraf_dr_source']) #^^
        icraf_dr_year =Year.objects.get(pk=self.request.POST['icraf_dr_year']) #^^
        icraf_dr_date_created = self.request.POST.get('icraf_dr_date_created', None) #^^
        icraf_dr_date_published = self.request.POST.get('icraf_dr_date_published', None) #^^
        icraf_dr_date_revised = self.request.POST.get('icraf_dr_date_revised', None) #^^
        
        #^^ validate date format
        if icraf_dr_date_created: #^^
            try: #^^
                parse(icraf_dr_date_created) #^^
            except ValueError: #^^
                icraf_dr_date_created = None #^^
        else: #^^
            icraf_dr_date_created = None #^^
        
        if icraf_dr_date_published: #^^
            try: #^^
                parse(icraf_dr_date_published) #^^
            except ValueError: #^^
                icraf_dr_date_published = None #^^
        else: #^^
            icraf_dr_date_published = None #^^
        
        if 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=self.request.POST['category_choice_field']) #^^
        except: #^^
            main_topic_category = None #^^
        
        main_regions = ','.join(self.request.POST.getlist('resource-regions')) #^^ save as comma separated ids
        
        main = Main( #^^
            category=icraf_dr_category, #^^
            coverage=icraf_dr_coverage, #^^
            source=icraf_dr_source, #^^
            year=icraf_dr_year, #^^
            basename=form.cleaned_data['doc_file'].name, #^^
            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 #^^
        ) #^^
        
        #^^ save icraf_dr_main and pass id to document model object
        main.save() #^^
        main_id = main.id #^^
        
        self.object = form.save(commit=False)
        self.object.owner = self.request.user
        resource_id = self.request.POST.get('resource', None)
        if resource_id:
            self.object.content_type = ResourceBase.objects.get(id=resource_id).polymorphic_ctype
            self.object.object_id = resource_id
        # by default, if RESOURCE_PUBLISHING=True then document.is_published
        # must be set to False
        is_published = True
        if settings.RESOURCE_PUBLISHING:
            is_published = False
        self.object.is_published = is_published
        
        self.object.main_id = main_id #^^
        
        try: #^^
            self.object.save() #^^
            main.document = self.object #^^
            main.save() #^^
        except: #^^
            main.delete() #^^
        
        #^^ self.object.save()
        #^^self.object.set_permissions(form.cleaned_data['permissions'])
        
        document = None #^^
        try: #^^
            #^^ alternate permission saving method
            print 'debug' #^^
            print self.object.id #^^
            document = Document.objects.get(id=self.object.id) #^^
            document.set_permissions(form.cleaned_data['permissions']) #^^
        except: #^^
            pass #^^

        abstract = None
        date = None
        regions = []
        keywords = []
        bbox = None
        
        #^^ start processing metadata fields
        owner = self.request.POST.get('resource-owner', None) #^^
        #title = self.request.POST['resource-title'] #^^ replaced by title
        #date = self.request.POST.get('resource-date'], None) #^^ replaced by icraf_dr_date_created
        date = icraf_dr_date_created #^^
        date_type = self.request.POST.get('resource-date_type', None) #^^
        #edition = self.request.POST['resource-edition'] #^^ replaced by icraf_dr_year
        edition = str(icraf_dr_year.year_num) #^^
        abstract = self.request.POST.get('resource-abstract', None) #^^
        purpose = self.request.POST.get('resource-purpose', None) #^^
        maintenance_frequency = self.request.POST.get('resource-maintenance_frequency', None) #^^
        regions = self.request.POST.getlist('resource-regions', None) #^^
        restriction_code_type = self.request.POST.get('resource-restriction_code_type', None) #^^
        constraints_other = self.request.POST.get('resource-constraints_other', None) #^^
        license = self.request.POST.get('resource-license', None) #^^
        language = self.request.POST.get('resource-language', None) #^^
        spatial_representation_type = self.request.POST.get('resource-spatial_representation_type', None) #^^
        temporal_extent_start = self.request.POST.get('resource-temporal_extent_start', None) #^^
        temporal_extent_end = self.request.POST.get('resource-temporal_extent_end', None) #^^
        supplemental_information = self.request.POST.get('resource-supplemental_information', None) #^^
        distribution_url = self.request.POST.get('resource-distribution_url', None) #^^
        distribution_description = self.request.POST.get('resource-distribution_description', None) #^^
        data_quality_statement = self.request.POST.get('resource-data_quality_statement', None) #^^
        featured = self.request.POST.get('resource-featured', False) #^^
        is_published = self.request.POST.get('resource-is_published', False) #^^
        thumbnail_url = self.request.POST.get('resource-thumbnail_url', None) #^^
        keywords = self.request.POST.get('resource-keywords', None) #^^
        poc = self.request.POST.get('resource-poc', None) #^^
        metadata_author = self.request.POST.get('resource-metadata_author', None) #^^
        category_choice_field = self.request.POST.get('category_choice_field', None) #^^
        doc_type = self.request.POST.get('doc_type', None) #^^
        
        if owner and owner.isdigit():
            try:
                owner = get_user_model().objects.get(id=owner)
                self.object.owner = owner
            except get_user_model().DoesNotExist:
                pass
        
        if date:
            self.object.date = date
        
        if date_type:
            self.object.date_type = date_type
        
        if edition:
            self.object.edition = edition
        
        if abstract:
            self.object.abstract = abstract
        
        if purpose:
            self.object.purpose = purpose
        
        if maintenance_frequency:
            self.object.maintenance_frequency = maintenance_frequency
        
        if restriction_code_type:
            try:
                self.object.restriction_code_type = RestrictionCodeType(id=restriction_code_type)
            except:
                pass
        
        if constraints_other:
            self.object.constraints_other = constraints_other
        
        if license:
            try:
                self.object.license = License(id=license)
            except:
                pass
        
        if language:
            self.object.language = language
        
        if spatial_representation_type:
            try:
                self.object.spatial_representation_type = SpatialRepresentationType(id=spatial_representation_type)
            except:
                pass
        
        if temporal_extent_start:
            try:
                parse(temporal_extent_start)
                self.object.temporal_extent_start = temporal_extent_start
            except ValueError:
                pass
        
        if temporal_extent_end:
            try:
                parse(temporal_extent_end)
                self.object.temporal_extent_end = temporal_extent_end
            except ValueError:
                pass
        
        if supplemental_information:
            self.object.supplemental_information = supplemental_information
        
        if distribution_url:
            self.object.distribution_url = distribution_url
        
        if distribution_description:
            self.object.distribution_description = distribution_description
        
        if data_quality_statement:
            self.object.data_quality_statement = data_quality_statement
        
        if featured != False:
            self.object.featured = True
        
        if is_published != False:
            self.object.is_published = True
        
        if thumbnail_url:
            val = URLValidator()
            try:
                val(thumbnail_url)
                if (thumbnail_url.lower().startswith(('http://', 'https://')) and thumbnail_url.lower().endswith(('.jpg', '.jpeg', '.png'))):
                    self.object.thumbnail_url = thumbnail_url
            except ValidationError:
                pass
        
        if len(keywords) > 0 and document != None:
            keywords = [keyword.strip() for keyword in keywords.split(',')]
            document.keywords.add(*keywords)
        
        if len(regions) > 0 and document != None:
            document.regions.add(*regions)
        
        if poc and poc.isdigit():
            try:
                contact = get_user_model().objects.get(id=poc)
                self.object.poc = contact
            except get_user_model().DoesNotExist:
                pass
        
        if metadata_author and metadata_author.isdigit():
            try:
                author = get_user_model().objects.get(id=metadata_author)
                self.object.metadata_author = author
            except get_user_model().DoesNotExist:
                pass
        
        if category_choice_field:
            try:
                self.object.category = TopicCategory(id=category_choice_field)
            except:
                pass
        
        self.object.save()
        
        if doc_type:
            try:
                Document.objects.filter(id=self.object.pk).update(doc_type=doc_type)
            except:
                pass
        #^^ end

        if getattr(settings, 'EXIF_ENABLED', False):
            try:
                from geonode.contrib.exif.utils import exif_extract_metadata_doc
                exif_metadata = exif_extract_metadata_doc(self.object)
                if exif_metadata:
                    date = exif_metadata.get('date', None)
                    keywords.extend(exif_metadata.get('keywords', []))
                    bbox = exif_metadata.get('bbox', None)
                    abstract = exif_metadata.get('abstract', None)
            except:
                print "Exif extraction failed."

        if getattr(settings, 'NLP_ENABLED', False):
            try:
                from geonode.contrib.nlp.utils import nlp_extract_metadata_doc
                nlp_metadata = nlp_extract_metadata_doc(self.object)
                if nlp_metadata:
                    regions.extend(nlp_metadata.get('regions', []))
                    keywords.extend(nlp_metadata.get('keywords', []))
            except:
                print "NLP extraction failed."

        """ #^^ overriden above in metadata saving
        if abstract:
            self.object.abstract = abstract
            self.object.save()

        if date:
            self.object.date = date
            self.object.date_type = "Creation"
            self.object.save()

        if len(regions) > 0:
            self.object.regions.add(*regions)

        if len(keywords) > 0:
            self.object.keywords.add(*keywords)
        """

        if bbox:
            bbox_x0, bbox_x1, bbox_y0, bbox_y1 = bbox
            Document.objects.filter(id=self.object.pk).update(
                bbox_x0=bbox_x0,
                bbox_x1=bbox_x1,
                bbox_y0=bbox_y0,
                bbox_y1=bbox_y1)

        if getattr(settings, 'SLACK_ENABLED', False):
            try:
                from geonode.contrib.slack.utils import build_slack_message_document, send_slack_message
                send_slack_message(build_slack_message_document("document_new", self.object))
            except:
                print "Could not send slack message for new document."

        #^^return HttpResponseRedirect(
        #^^    reverse(
        #^^        'document_metadata',
        #^^        args=(
        #^^            self.object.id,
        #^^        )))
        
        #^^ start send email notification to 'Pengelola Basis Data' group managers
        if 'notification' in settings.INSTALLED_APPS and document != None:
            try:
                group_approver = GroupProfile.objects.get(title='Pengelola Basis Data')
                if group_approver:
                    group_managers = group_approver.get_managers()
                    if group_managers:
                        notif_ctx = {
                            'resource': document,
                        }
                        print 'sending notification'
                        notification.send(group_managers, 'document_created', notif_ctx)
            except:
                pass
        #^^ end

        #^^ redirect to document detail instead of document metadata page
        return HttpResponseRedirect( #^^
            reverse( #^^
                'document_detail', #^^
                args=( #^^
                    self.object.id, #^^
                ))) #^^
Beispiel #3
0
def layer_upload(request, template='upload/layer_upload.html'):
    if request.method == 'GET':
        
        ##icraf_dr_categories = Category.objects.all() #^^
        icraf_dr_categories = Category.objects.order_by('cat_num') #^^
        ##icraf_dr_coverages = Coverage.objects.all() #^^
        icraf_dr_coverages = Coverage.objects.order_by('cov_num') #^^
        ##icraf_dr_sources = Source.objects.all() #^^
        icraf_dr_sources = Source.objects.order_by('src_num') #^^
        ##icraf_dr_years = Year.objects.all() #^^
        icraf_dr_years = Year.objects.order_by('year_num') #^^
        
        layer_form = LayerForm(prefix="resource") #^^
        category_form = CategoryForm(prefix="category_choice_field") #^^
        
        ctx = {
            'icraf_dr_categories': icraf_dr_categories, #^^
            'icraf_dr_coverages': icraf_dr_coverages, #^^
            'icraf_dr_sources': icraf_dr_sources, #^^
            'icraf_dr_years': icraf_dr_years, #^^
            "layer_form": layer_form, #^^
            "category_form": category_form, #^^
            'charsets': CHARSETS,
            'is_layer': True,
        }
        return render_to_response(template,
                                  RequestContext(request, ctx))
    elif request.method == 'POST':
        form = NewLayerUploadForm(request.POST, request.FILES)
        tempdir = None
        errormsgs = []
        out = {'success': False}

        if form.is_valid():
            title = form.cleaned_data["layer_title"]

            # Replace dots in filename - GeoServer REST API upload bug
            # and avoid any other invalid characters.
            # Use the title if possible, otherwise default to the filename
            if title is not None and len(title) > 0:
                name_base = title
            else:
                name_base, __ = os.path.splitext(
                    form.cleaned_data["base_file"].name)

            name = slugify(name_base.replace(".", "_"))

            try:
                # Moved this inside the try/except block because it can raise
                # exceptions when unicode characters are present.
                # This should be followed up in upstream Django.
                
                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 #^^
                
                main = Main( #^^
                    category=icraf_dr_category, #^^
                    coverage=icraf_dr_coverage, #^^
                    source=icraf_dr_source, #^^
                    year=icraf_dr_year, #^^
                    basename=name_base, #^^
                    topic_category = TopicCategory(id=request.POST['category_choice_field']), #^^
                    regions = request.POST['regions'], #^^
                    date_created=icraf_dr_date_created, #^^
                    date_published=icraf_dr_date_published, #^^
                    date_revised=icraf_dr_date_revised #^^
                ) #^^
                
                #^^ save icraf_dr_main and pass id to file_upload below
                main.save() #^^
                main_id = main.id #^^
                
                #^^ get metadata form values
                form_metadata = json.dumps({ #^^
                    'owner': request.POST['owner'], #^^
                    'title': request.POST['title'], #^^
                    #'date': request.POST['date'], #^^ replaced_by icraf_dr_date_created
                    'date': icraf_dr_date_created, #^^
                    'date_type': request.POST['date_type'], #^^
                    #'edition': request.POST['edition'], #^^ replaced by icraf_dr_year
                    'edition': str(icraf_dr_year.year_num), #^^
                    'abstract': request.POST['abstract'], #^^
                    'purpose': request.POST['purpose'], #^^
                    'maintenance_frequency': request.POST['maintenance_frequency'], #^^
                    'regions': request.POST['regions'], #^^
                    'restriction_code_type': request.POST['restriction_code_type'], #^^
                    'constraints_other': request.POST['constraints_other'], #^^
                    'license': request.POST['license'], #^^
                    'language': request.POST['language'], #^^
                    'spatial_representation_type': request.POST['spatial_representation_type'], #^^
                    'temporal_extent_start': request.POST['temporal_extent_start'], #^^
                    'temporal_extent_end': request.POST['temporal_extent_end'], #^^
                    'supplemental_information': request.POST['supplemental_information'], #^^
                    'distribution_url': request.POST['distribution_url'], #^^
                    'distribution_description': request.POST['distribution_description'], #^^
                    'data_quality_statement': request.POST['data_quality_statement'], #^^
                    'featured': request.POST.get('featured', False), #^^
                    'is_published': request.POST.get('is_published', False), #^^
                    'thumbnail_url': request.POST['thumbnail_url'], #^^
                    'keywords': request.POST['keywords'], #^^
                    'poc': request.POST['poc'], #^^
                    'metadata_author': request.POST['metadata_author'], #^^
                    'category_choice_field': request.POST['category_choice_field'], #^^
                }) #^^
                
                tempdir, base_file = form.write_files()
                saved_layer = file_upload(
                    base_file,
                    name=name,
                    user=request.user,
                    overwrite=False,
                    charset=form.cleaned_data["charset"],
                    abstract=form.cleaned_data["abstract"],
                    title=form.cleaned_data["layer_title"],
                    main_id=main_id, #^^
                    form_metadata=form_metadata, #^^
                )

            except Exception as e:
                print 'debug layer creation failed, deleting main' #^^
                main.delete() #^^
                
                exception_type, error, tb = sys.exc_info()
                logger.exception(e)
                out['success'] = False
                out['errors'] = str(error)
                # Assign the error message to the latest UploadSession from that user.
                latest_uploads = UploadSession.objects.filter(user=request.user).order_by('-date')
                if latest_uploads.count() > 0:
                    upload_session = latest_uploads[0]
                    upload_session.error = str(error)
                    upload_session.traceback = traceback.format_exc(tb)
                    upload_session.context = log_snippet(CONTEXT_LOG_FILE)
                    upload_session.save()
                    out['traceback'] = upload_session.traceback
                    out['context'] = upload_session.context
                    out['upload_session'] = upload_session.id
            else:
                out['success'] = True
                if hasattr(saved_layer, 'info'):
                    out['info'] = saved_layer.info
                out['url'] = reverse(
                    'layer_detail', args=[
                        saved_layer.service_typename])

                upload_session = saved_layer.upload_session
                upload_session.processed = True
                upload_session.save()
                permissions = form.cleaned_data["permissions"]
                if permissions is not None and len(permissions.keys()) > 0:
                    saved_layer.set_permissions(permissions)

            finally:
                if tempdir is not None:
                    shutil.rmtree(tempdir)
        else:
            for e in form.errors.values():
                errormsgs.extend([escape(v) for v in e])

            out['errors'] = form.errors
            out['errormsgs'] = errormsgs

        if out['success']:
            status_code = 200
        else:
            status_code = 400
        return HttpResponse(
            json.dumps(out),
            mimetype='application/json',
            status=status_code)