Beispiel #1
0
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
    external_person = layer.external_person

    if request.method == "POST":
        layer_form = LayerForm(request.POST, instance=layer, prefix="resource")
        lkd_project_form = LinkedProjectsForm(request.POST, instance=layer)
        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")
        lkd_project_form = LinkedProjectsForm(instance=layer)
        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() and lkd_project_form.is_valid():
        new_poc = layer_form.cleaned_data['poc']
        new_ep = layer_form.cleaned_data['external_person']
        new_keywords = layer_form.cleaned_data['keywords']

        if new_poc is None:
            if poc is None:
                poc_form = ExternalPersonForm(
                    request.POST,
                    prefix="poc",
                    instance=poc)
            else:
                poc_form = ExternalPersonForm(request.POST, prefix="poc")
            if poc_form.has_changed and poc_form.is_valid():
                new_poc = poc_form.save()

        if new_ep is None:
            if external_person is None:
                ep_form = ExternalPersonForm(
                    request.POST,
                    prefix="external_person",
                    instance=external_person)
            else:
                ep_form = ExternalPersonForm(request.POST, prefix="external_person")
            if ep_form.has_changed and ep_form.is_valid():
                new_ep = ep_form.save()

        # Permite clasificar las capas segun el tipo de fuente capturado
        # esto ayuda la ejecuión del filtrado en la lista de capas.
        st = layer_form.cleaned_data['source']
        st_low = st.lower().replace(" ", "")
        if st_low == '':
            src_type = 'otro'
        elif st_low == 'centrogeo':
            src_type = 'centrogeo'
        else:
            src_type = 'externo'

        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_type = form["attribute_type"]
            la.visible = form["visible"]
            la.display_order = form["display_order"]
            la.save()

        if new_poc is not None and new_ep 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.external_person = new_ep
            lkd_project_form.save()
            Layer.objects.filter(id=the_layer.id).update(
                category=new_category, external_person=new_ep,
                source_type=src_type)

            return HttpResponseRedirect(
                reverse(
                    'layer_detail',
                    args=(
                        layer.service_typename,
                    )))

    if external_person is None:
        ep_form = ExternalPersonForm(instance=external_person, prefix="external_person")
    else:
        layer_form.fields['external_person'].initial = external_person
        ep_form = ExternalPersonForm(prefix="external_person")
        ep_form.hidden = True

    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,
        "ep_form": ep_form,
        "poc_form": poc_form,
        "lkd_project_form": lkd_project_form,
        "author_form": author_form,
        "attribute_form": attribute_form,
        "category_form": category_form,
    }))
Beispiel #2
0
def project_metadata(request, docid, template="project_metadata.html"):

    document = None
    try:
        document = _resolve_document_geo(request, docid, "base.change_resourcebase", _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
        external_person = document.external_person

        if request.method == "POST":
            document_form = ProjectForm(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 = ProjectForm(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_ep = document_form.cleaned_data["external_person"]
            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.has_changed and poc_form.is_valid():
                    new_poc = poc_form.save()

            if new_ep is None:
                if external_person is None:
                    print "EP is None"
                    ep_form = ExternalPersonForm(request.POST, prefix="external_person", instance=external_person)
                else:
                    ep_form = ExternalPersonForm(request.POST, prefix="external_person")
                if ep_form.has_changed and ep_form.is_valid():
                    print "entro a salvar"
                    new_ep = ep_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_ep 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)
                Project.objects.filter(id=the_document.id).update(category=new_category, external_person=new_ep)
                return HttpResponseRedirect(reverse("project_detail", args=(document.id,)))

        if external_person is None:
            ep_form = ExternalPersonForm(instance=external_person, prefix="external_person")
        else:
            document_form.fields["external_person"].initial = external_person
            ep_form = ExternalPersonForm(prefix="external_person")
            ep_form.hidden = True

        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

        return render_to_response(
            template,
            RequestContext(
                request,
                {
                    "document": document,
                    "document_form": document_form,
                    "ep_form": ep_form,
                    "poc_form": poc_form,
                    "author_form": author_form,
                    "category_form": category_form,
                },
            ),
        )
Beispiel #3
0
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
        external_person = document.external_person

        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_ep = document_form.cleaned_data['external_person']
            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.has_changed and poc_form.is_valid():
                    new_poc = poc_form.save()

            if new_ep is None:
                if external_person is None:
                    ep_form = ExternalPersonForm(
                        request.POST,
                        prefix="external_person",
                        instance=external_person)
                else:
                    ep_form = ExternalPersonForm(request.POST, prefix="external_person")
                if ep_form.has_changed and ep_form.is_valid():
                    new_ep = ep_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_ep is not None:
                the_document = document_form.save()
                the_document.poc = new_poc
                # the_document.external_person = new_ep
                # the_document.metadata_author = new_author
                the_document.keywords.add(*new_keywords)
                Document.objects.filter(id=the_document.id).update(
                    category=new_category, external_person=new_ep)
                return HttpResponseRedirect(
                    reverse(
                        'document_detail',
                        args=(
                            document.id,
                        )))

        if external_person is None:
            try:
                document_form.fields['external_person'].initial = ExternalPerson.objects.get(name='Mismo que contacto', last_name='registrado')
                print document_form.fields['external_person'].initial
            finally:
                print "Se ejecuto bloque try-except"

            ep_form = ExternalPersonForm(prefix="external_person")
            ep_form.hidden = True
        else:
            document_form.fields['external_person'].initial = external_person
            ep_form = ExternalPersonForm(prefix="external_person")
            ep_form.hidden = True

        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

        return render_to_response(template, RequestContext(request, {
            "document": document,
            "document_form": document_form,
            "ep_form": ep_form,
            "poc_form": poc_form,
            "author_form": author_form,
            "category_form": category_form,
        }))