path: root/archaeological_context_records/views.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright (C) 2010-2025  Étienne Loks  <etienne.loks at iggdrasil dot net>

# 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.exceptions import PermissionDenied
from django.db.models import Q
from django.http import HttpResponse, HttpResponseRedirect, Http404
from django.shortcuts import redirect, render
from django.urls import reverse
from ishtar_common.utils import gettext_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, get_relation_modify
from archaeological_context_records import forms

from ishtar_common.views import (
    IshtarMixin,
    LoginRequiredMixin,
    QAItemForm,
    QABaseLockView,
    wizard_is_available,
    QAItemEditForm,
)
from ishtar_common.views_item import get_item, get_autocomplete_query, 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):
    query = get_autocomplete_query(
        request, "archaeological_context_records", "contextrecord"
    )
    if query is None:
        return HttpResponse(content_type="text/plain")
    q = request.GET.get("term")
    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(operation__code_patriarche__icontains=q)
            | Q(cached_label__icontains=q)
            | Q(label__icontains=q)
        )
        query = query & qt
    limit = 15
    items = models.ContextRecord.objects.filter(query).values_list(
        "pk", "cached_label").order_by("cached_label")[:limit]
    data = json.dumps([
        {"id": item[0], "value": item[1][: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),
    ("interpretation-record_creation", forms.RecordFormInterpretation),
    ("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),
    ("interpretation-record_modification", forms.RecordFormInterpretation),
    ("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)


context_record_modify_relations = get_relation_modify(
    models.ContextRecord, models.RecordRelations,
    forms.RecordRelationsFormSet, "context-record-relation-modify",
    filter_operations=True
)


def get_dating_form(model, dating_model, url_name):
    def _dating_form(request, pk, dating_pk=None, current_right=None):
        try:
            item = model.objects.get(pk=pk)
        except model.DoesNotExist:
            raise Http404()
        if "_own_" in current_right:
            if not request.user.has_perm(current_right, item):
                raise PermissionDenied()
        elif current_right:
            if not request.user.has_perm(current_right):
                raise PermissionDenied()
        initial = {}
        if dating_pk:
            try:
                dating_item = dating_model.objects.get(pk=dating_pk)
                initial = dict(
                    (attr, getattr(dating_item, attr))
                    for attr in [
                         "pk", "reference", "period_id", "start_date", "end_date",
                         "quality_id", "dating_type_id", "precise_dating"]
                )
            except dating_model.DoesNotExist:
                raise Http404()
        if request.method == 'POST':
            form = forms.QADating(request.POST, dating_model=dating_model,
                                  current_item=item)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(reverse("success"))
        else:
            form = forms.QADating(dating_model=dating_model,
                                  current_item=item, initial=initial)
        button_name = _("Add") if not dating_pk else _("Modify")
        icon = "fa fa-plus" if not dating_pk else "fa fa-pencil"
        url_args = [pk]
        if dating_pk:
            url_args.append(dating_pk)
        return render(
            request,
            "ishtar/forms/qa_form.html", {
                "page_name": _("Dating"),
                "icon": icon,
                "action_name": button_name,
                "form": form,
                "url": reverse(url_name, args=url_args)
            })
    return _dating_form


context_record_dating_add = get_dating_form(
    models.ContextRecord, models.ContextRecordDating, "context-record-dating-add"
)


context_record_dating_modify = get_dating_form(
    models.ContextRecord, models.ContextRecordDating, "context-record-dating-modify"
)


def get_dating_delete(model, dating_model, url_name):
    def _dating_form(request, dating_pk, current_right=None):
        try:
            dating_item = dating_model.objects.get(pk=dating_pk)
        except dating_model.DoesNotExist:
            raise Http404()
        pk = getattr(dating_item, dating_model.CURRENT_MODEL_ATTR + "_id")
        try:
            item = model.objects.get(pk=pk)
        except model.DoesNotExist:
            raise Http404()
        if "_own_" in current_right:
            if not request.user.has_perm(current_right, item):
                raise PermissionDenied()
        elif current_right:
            if not request.user.has_perm(current_right):
                raise PermissionDenied()
        dating_item.delete()
        return HttpResponseRedirect(reverse("success"))
    return _dating_form


context_record_dating_delete = get_dating_delete(
    models.ContextRecord, models.ContextRecordDating, "context-record-dating-delete"
)


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")
    icon = "fa fa-plus"
    action_name = _("Create")

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

    def form_valid(self, form):
        cr = form.save(self.items)
        url = reverse(models.ContextRecord.SHOW_URL, kwargs={"pk": cr.pk})
        return HttpResponseRedirect(reverse("success") + f"?load_window={url}")


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


class QAContextRecordForm(QAItemEditForm):
    model = models.ContextRecord
    form_class = forms.QAContextRecordFormMulti