path: root/archaeological_context_records/views.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright (C) 2010-2016  Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.

# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# See the file COPYING for details.

import json

from django.core.urlresolvers import reverse
from django.db.models import Q
from django.http import HttpResponse, HttpResponseRedirect, Http404
from django.shortcuts import redirect
from ishtar_common.utils import ugettext_lazy as _
from django.views.generic import RedirectView

from ishtar_common.models import QuickAction
from archaeological_operations.models import Operation
from archaeological_context_records import models

from archaeological_operations.views import site_extra_context
from archaeological_context_records import forms
from ishtar_common.utils import put_session_message

from ishtar_common.views import (
    IshtarMixin,
    LoginRequiredMixin,
    QAItemForm,
    QABaseLockView,
    wizard_is_available,
)
from ishtar_common.views_item import display_item, get_item, show_item, revert_item
from archaeological_context_records import wizards

show_contextrecord = show_item(
    models.ContextRecord, "contextrecord", extra_dct=site_extra_context
)
revert_contextrecord = revert_item(models.ContextRecord)


def autocomplete_contextrecord(request):
    if not request.user.has_perm(
        "archaeological_context_records.view_contextrecord", models.ContextRecord
    ) and not request.user.has_perm(
        "archaeological_context_records.view_own_contextrecord",
        models.ArchaeologicalSite,
    ):
        return HttpResponse(content_type="text/plain")
    if not request.GET.get("term"):
        return HttpResponse(content_type="text/plain")
    q = request.GET.get("term")
    query = Q()
    if request.GET.get("operation__pk"):
        query = Q(operation__pk=request.GET.get("operation__pk"))
    for q in q.split(" "):
        qt = (
            Q(parcel__section__icontains=q)
            | Q(parcel__parcel_number__icontains=q)
            | Q(cached_label__icontains=q)
            | Q(label__icontains=q)
        )
        query = query & qt
    limit = 15
    items = models.ContextRecord.objects.filter(query).order_by(
        "parcel__section", "parcel__parcel_number", "label"
    )[:limit]
    data = json.dumps([{"id": item.pk, "value": str(item)[:60]} for item in items])
    return HttpResponse(data, content_type="text/plain")


get_contextrecord = get_item(
    models.ContextRecord,
    "get_contextrecord",
    "contextrecord",
    search_form=forms.RecordSelect,
)
get_contextrecord_for_ope = get_item(
    models.ContextRecord,
    "get_contextrecord",
    "contextrecord",
    own_table_cols=models.ContextRecord.TABLE_COLS_FOR_OPE,
)

get_contextrecordrelation = get_item(
    models.RecordRelationView,
    "get_contextrecordrelation",
    "contextrecordrelation",
    specific_perms=["view_recordrelation"],
    do_not_deduplicate=True,
    extra_request_keys=models.RecordRelationView.EXTRA_REQUEST_KEYS,
)

get_contextrecordrelationdetail = get_item(
    models.RecordRelations,
    "get_contextrecordrelationdetail",
    "contextrecordrelationdetail",
    specific_perms=["view_recordrelation"],
)

record_search_wizard = wizards.RecordSearch.as_view(
    [("general-record_search", forms.RecordFormSelection)],
    label=_("Context record search"),
    url_name="record_search",
)

record_creation_steps = [
    ("selec-record_creation", forms.OperationRecordFormSelection),
    ("general-record_creation", forms.RecordFormGeneral),
    ("datings-record_creation", forms.DatingFormSet),
    ("interpretation-record_creation", forms.RecordFormInterpretation),
    ("relations-record_creation", forms.RecordRelationsFormSet),
    ("final-record_creation", forms.FinalForm),
]

record_creation_wizard = wizards.RecordWizard.as_view(
    record_creation_steps,
    label=_("New context record"),
    url_name="record_creation",
)

record_modification_steps = [
    ("selec-record_modification", forms.RecordFormSelection),
    ("operation-record_modification", forms.OperationFormSelection),
    ("general-record_modification", forms.RecordFormGeneral),
    ("datings-record_modification", forms.DatingFormSet),
    ("interpretation-record_modification", forms.RecordFormInterpretation),
    ("relations-record_modification", forms.RecordRelationsFormSet),
    ("final-record_modification", forms.FinalForm),
]

record_modification_wizard = wizards.RecordModifWizard.as_view(
    record_modification_steps,
    label=_("Context record modification"),
    url_name="record_modification",
)


def record_modify(request, pk):
    if not wizard_is_available(
        record_modification_wizard, request, models.ContextRecord, pk
    ):
        return HttpResponseRedirect("/")

    wizards.RecordModifWizard.session_set_value(
        request, "selec-record_modification", "pk", pk, reset=True
    )
    return redirect(
        reverse("record_modification", kwargs={"step": "operation-record_modification"})
    )


record_deletion_wizard = wizards.RecordDeletionWizard.as_view(
    [
        ("selec-record_deletion", forms.RecordFormMultiSelection),
        ("final-record_deletion", forms.RecordDeletionForm),
    ],
    label=_("Context record deletion"),
    url_name="record_deletion",
)


def record_delete(request, pk):
    if not wizard_is_available(
        record_deletion_wizard, request, models.ContextRecord, pk
    ):
        return HttpResponseRedirect("/")

    wizards.RecordDeletionWizard.session_set_value(
        request, "selec-record_deletion", "pks", pk, reset=True
    )
    return redirect(
        reverse("record_deletion", kwargs={"step": "final-record_deletion"})
    )


def reset_wizards(request):
    for wizard_class, url_name in (
        (wizards.RecordWizard, "record_creation"),
        (wizards.RecordModifWizard, "record_modification"),
        (wizards.RecordDeletionWizard, "record_deletion"),
    ):
        wizard_class.session_reset(request, url_name)


class GenerateRelationImage(IshtarMixin, LoginRequiredMixin, RedirectView):
    upper_model = models.Operation
    model = models.ContextRecord

    def get_redirect_url(self, *args, **kwargs):
        if self.upper_item:
            return (
                reverse(
                    "display-item", args=[self.upper_model.SLUG, self.upper_item.pk]
                )
                + "#cr"
            )
        return (
            reverse("display-item", args=[self.model.SLUG, self.item.pk]) + "#relations"
        )

    def get(self, request, *args, **kwargs):
        self.upper_item = None
        render_type = kwargs.get("type", None)
        if render_type == "full" and self.upper_model:
            try:
                self.upper_item = self.upper_model.objects.get(pk=kwargs["pk"])
            except self.model.DoesNotExist:
                raise Http404()
            q = self.upper_item.context_record_relations_q()
            if not q.count():
                return super(GenerateRelationImage, self).get(request, *args, **kwargs)
            self.item = q.all()[0].left_record
        else:
            try:
                self.item = self.model.objects.get(pk=kwargs["pk"])
            except self.model.DoesNotExist:
                raise Http404()
        render_above, render_below, full = True, True, False
        if render_type == "above":
            render_below = False
        elif render_type == "below":
            render_above = False
        elif render_type == "full":
            full = True
        self.item.generate_relation_image(
            render_below=render_below, render_above=render_above, full=full
        )
        return super(GenerateRelationImage, self).get(request, *args, **kwargs)


class QAOperationContextRecordView(QAItemForm):
    template_name = "ishtar/forms/qa_operation_contextrecord.html"
    model = Operation
    form_class = forms.QAOperationCR
    page_name = _("Context record")

    def get_quick_action(self):
        return QuickAction(
            url="operation-qa-contextrecord",
            icon_class="fa fa-plus",
            text=_("Add context record"),
            target="one",
            rights=["add_contextrecord", "add_own_contextrecord"],
        )

    def form_valid(self, form):
        form.save(self.items)
        return HttpResponseRedirect(reverse("success"))


class QAContextRecordLockView(QABaseLockView):
    model = models.ContextRecord
    base_url = "contextrecord-qa-lock"


class QAContextRecordDuplicateFormView(QAItemForm):
    template_name = "ishtar/forms/qa_contextrecord_duplicate.html"
    model = models.ContextRecord
    page_name = _("Duplicate")
    form_class = forms.QAContextRecordDuplicateForm
    base_url = "contextrecord-qa-duplicate"

    def get_form_kwargs(self):
        kwargs = super(QAContextRecordDuplicateFormView, self).get_form_kwargs()
        kwargs["user"] = self.request.user
        return kwargs

    def form_valid(self, form):
        form.save()
        return HttpResponseRedirect(reverse("success"))

    def get_context_data(self, **kwargs):
        data = super(QAContextRecordDuplicateFormView, self).get_context_data(**kwargs)
        data["action_name"] = _("Duplicate")
        data["operation"] = self.items[0].operation
        return data