path: root/ishtar_common/admin.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (C) 2010-2017 É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 csv

from ajax_select import make_ajax_form
from ajax_select.fields import AutoCompleteSelectField, \
    AutoCompleteSelectMultipleField

from django.conf import settings
from django.contrib import admin
from django.contrib.auth.admin import GroupAdmin, UserAdmin
from django.contrib.auth.models import Group, User
from django.contrib.contenttypes.models import ContentType
from django.contrib.sites.admin import SiteAdmin
from django.contrib.sites.models import Site
from django.contrib.gis.forms import PointField, OSMWidget, MultiPolygonField
from django.core.cache import cache
from django.forms import BaseInlineFormSet
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render
from django.template.defaultfilters import slugify
from django.utils.translation import ugettext_lazy as _

from django import forms

from ishtar_common import models
from ishtar_common.apps import admin_site
from ishtar_common.utils import get_cache

from ishtar_common import forms as common_forms
from archaeological_files import forms as file_forms
from archaeological_operations import forms as operation_forms
from archaeological_context_records import forms as context_record_forms
from archaeological_finds import forms as find_forms, \
    forms_treatments as treatment_forms
from archaeological_warehouse import forms as warehouse_forms


ISHTAR_FORMS = [common_forms, file_forms, operation_forms,
                context_record_forms, find_forms, treatment_forms,
                warehouse_forms]


class ImportGenericForm(forms.Form):
    _selected_action = forms.CharField(widget=forms.MultipleHiddenInput)
    csv_file = forms.FileField(
        "CSV file", help_text="Only unicode encoding is managed - convert your"
        " file first")


def gen_import_generic(self, request, queryset):
    form = None

    if 'apply' in request.POST:
        form = ImportGenericForm(request.POST, request.FILES)

        if form.is_valid():
            csv_file = request.FILES['csv_file']
            reader = csv.reader(csv_file)
            idx = 0
            for row in reader:
                slug = slugify(row[0])
                if self.model.objects.filter(txt_idx=slug).count():
                    continue
                obj, c = self.model.objects.get_or_create(
                    label=row[0], txt_idx=slug)
                if c:
                    idx += 1
            self.message_user(request, "Successfully added %d new items." % (
                idx))
            return HttpResponseRedirect(request.get_full_path())
    if not form:
        form = ImportGenericForm(
            initial={'_selected_action':
                     request.POST.getlist(admin.ACTION_CHECKBOX_NAME)})
    return render(request, 'admin/import_from_csv.html', {'csv_form': form})


gen_import_generic.short_description = "Import from a CSV file"


def export_as_csv_action(description=_(u"Export selected as CSV file"),
                         fields=None, exclude=None, header=True):
    """
    This function returns an export csv action
    'fields' and 'exclude' work like in django ModelForm
    'header' is whether or not to output the column names as the first row
    """
    def export_as_csv(modeladmin, request, queryset):
        """
        Generic csv export admin action.
        based on http://djangosnippets.org/snippets/1697/
        """
        opts = modeladmin.model._meta
        field_names = set([field.name for field in opts.fields])
        if fields:
            fieldset = set(fields)
            field_names = field_names & fieldset
        elif exclude:
            excludeset = set(exclude)
            field_names = field_names - excludeset

        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename=%s.csv' % \
            unicode(opts).replace('.', '_')

        writer = csv.writer(response)
        if header:
            writer.writerow(list(field_names))
        for obj in queryset:
            writer.writerow([
                unicode(getattr(obj, field)).encode("utf-8", "replace")
                for field in field_names])
        return response
    export_as_csv.short_description = description
    return export_as_csv


class HistorizedObjectAdmin(admin.ModelAdmin):
    readonly_fields = ['history_creator', 'history_modifier', 'search_vector']

    def save_model(self, request, obj, form, change):
        obj.history_modifier = request.user
        obj.save()

    def get_readonly_fields(self, request, obj=None):
        if obj:  # editing an existing object
            return tuple(self.readonly_fields or []) + tuple(['imports'])
        return self.readonly_fields

    def get_exclude(self, request, obj=None):
        if not obj:
            return tuple(self.exclude or []) + tuple(['imports'])
        return self.exclude


class MyGroupAdmin(GroupAdmin):
    class Media:
        css = {
            "all": ("media/admin.css",)
        }


admin_site.register(User, UserAdmin)
admin_site.register(Group, MyGroupAdmin)
admin_site.register(Site, SiteAdmin)


class IshtarSiteProfileAdmin(admin.ModelAdmin):
    list_display = ('label', 'slug', 'active', 'files', 'context_record',
                    'find', 'warehouse', 'mapping', 'preservation')
    model = models.IshtarSiteProfile


admin_site.register(models.IshtarSiteProfile, IshtarSiteProfileAdmin)


class DepartmentAdmin(admin.ModelAdmin):
    list_display = ('number', 'label',)
    model = models.Department


admin_site.register(models.Department, DepartmentAdmin)


class OrganizationAdmin(HistorizedObjectAdmin):
    list_display = ('pk', 'name', 'organization_type')
    list_filter = ("organization_type",)
    search_fields = ('name',)
    exclude = ('merge_key', 'merge_exclusion', 'merge_candidate', )
    model = models.Organization


admin_site.register(models.Organization, OrganizationAdmin)


class PersonAdmin(HistorizedObjectAdmin):
    list_display = ('pk', 'name', 'surname', 'raw_name', 'email')
    list_filter = ("person_types",)
    search_fields = ('name', 'surname', 'email', 'raw_name')
    exclude = ('merge_key', 'merge_exclusion', 'merge_candidate', )
    form = make_ajax_form(models.Person, {'attached_to': 'organization'})
    model = models.Person


admin_site.register(models.Person, PersonAdmin)


class AdminRelatedTownForm(forms.ModelForm):
    class Meta:
        model = models.Town.children.through
        exclude = []
    from_town = AutoCompleteSelectField(
        'town', required=True, label=_(u"Parent"))


class AdminTownForm(forms.ModelForm):
    class Meta:
        model = models.Town
        exclude = ['imports']
    center = PointField(label=_(u"Center"), required=False,
                        widget=OSMWidget)
    limit = MultiPolygonField(label=_(u"Limit"), required=False,
                              widget=OSMWidget)
    children = AutoCompleteSelectMultipleField('town', required=False,
                                               label=_(u"Town children"))


class TownParentInline(admin.TabularInline):
    model = models.Town.children.through
    fk_name = 'to_town'
    form = AdminRelatedTownForm
    verbose_name = _(u"Parent")
    verbose_name_plural = _(u"Parents")
    extra = 1


class TownAdmin(admin.ModelAdmin):
    model = models.Town
    list_display = ['name', 'year']
    search_fields = ['name']
    readonly_fields = ['cached_label']
    if settings.COUNTRY == 'fr':
        list_display += ['numero_insee']
        search_fields += ['numero_insee', 'departement__label', ]
        list_filter = ("departement",)
    form = AdminTownForm
    inlines = [TownParentInline]
    actions = [export_as_csv_action(exclude=['center', 'limit'])]


admin_site.register(models.Town, TownAdmin)


class AuthorAdmin(admin.ModelAdmin):
    list_display = ['person', 'author_type']
    list_filter = ("author_type",)
    search_fields = ('person__name', 'person__surname',
                     'person__attached_to__name')
    model = models.Author
    form = make_ajax_form(models.Author, {'person': 'person'})


admin_site.register(models.Author, AuthorAdmin)


class PersonTypeAdmin(admin.ModelAdmin):
    list_display = ['label', 'txt_idx', 'available', 'comment']
    model = models.PersonType
    filter_vertical = ('groups',)


admin_site.register(models.PersonType, PersonTypeAdmin)


class GlobalVarAdmin(admin.ModelAdmin):
    list_display = ['slug', 'description', 'value']


admin_site.register(models.GlobalVar, GlobalVarAdmin)


class GeneralTypeAdmin(admin.ModelAdmin):
    list_display = ['label', 'txt_idx', 'available', 'comment']
    search_fields = ('label', 'txt_idx', 'comment',)
    actions = ['import_generic', export_as_csv_action()]
    prepopulated_fields = {"txt_idx": ("label",)}
    import_generic = gen_import_generic


general_models = [models.OrganizationType, models.SourceType,
                  models.AuthorType, models.TitleType, models.Format,
                  models.SupportType]
for model in general_models:
    admin_site.register(model, GeneralTypeAdmin)


class ImporterDefaultValuesInline(admin.TabularInline):
    model = models.ImporterDefaultValues


class ImporterDefaultAdmin(admin.ModelAdmin):
    list_display = ('importer_type', 'target')
    model = models.ImporterDefault
    inlines = (ImporterDefaultValuesInline,)


admin_site.register(models.ImporterDefault, ImporterDefaultAdmin)


class ImporterTypeAdmin(admin.ModelAdmin):
    list_display = ('name', 'associated_models', 'available')


admin_site.register(models.ImporterType, ImporterTypeAdmin)


class RegexpAdmin(admin.ModelAdmin):
    list_display = ('name', 'description', "regexp")


admin_site.register(models.Regexp, RegexpAdmin)


class ImporterDuplicateFieldInline(admin.TabularInline):
    model = models.ImporterDuplicateField


class ImportTargetForm(forms.ModelForm):
    class Meta:
        model = models.ImportTarget
        exclude = []
        widgets = {
            'comment': forms.TextInput
        }


class ImportTargetInline(admin.TabularInline):
    model = models.ImportTarget
    extra = 1
    form = ImportTargetForm


class ImporterColumnAdmin(admin.ModelAdmin):
    list_display = ('label', 'importer_type', 'col_number', 'description',
                    'targets_lbl', 'duplicate_fields_lbl', 'required')
    list_filter = ('importer_type',)
    inlines = (ImportTargetInline, ImporterDuplicateFieldInline)


admin_site.register(models.ImporterColumn, ImporterColumnAdmin)


class ImporterModelAdmin(admin.ModelAdmin):
    list_display = ('name', 'klass')
    model = models.ImporterModel


admin_site.register(models.ImporterModel, ImporterModelAdmin)


class FormaterTypeAdmin(admin.ModelAdmin):
    list_display = ('formater_type', 'options')


admin_site.register(models.FormaterType, FormaterTypeAdmin)


class ImportAdmin(admin.ModelAdmin):
    list_display = ('name', 'importer_type', 'imported_file', 'user', 'state',
                    'creation_date')
    form = make_ajax_form(models.Import, {'user': 'ishtaruser'})


admin_site.register(models.Import, ImportAdmin)


class TargetKeyGroupAdmin(admin.ModelAdmin):
    list_display = ('name', 'all_user_can_use', 'all_user_can_modify',
                    'available')
    search_fields = ('name',)


admin_site.register(models.TargetKeyGroup, TargetKeyGroupAdmin)


class TargetKeyAdmin(admin.ModelAdmin):
    list_display = ('target', 'importer_type', 'column_nb', 'key',
                    'value', 'is_set')
    list_filter = ("is_set", "target__column__importer_type")
    search_fields = ('target__target', 'value', 'key')


admin_site.register(models.TargetKey, TargetKeyAdmin)


class OperationTypeAdmin(GeneralTypeAdmin):
    list_display = GeneralTypeAdmin.list_display + ['order', 'preventive']
    model = models.OperationType


admin_site.register(models.OperationType, OperationTypeAdmin)


class SpatialReferenceSystemAdmin(GeneralTypeAdmin):
    list_display = GeneralTypeAdmin.list_display + ['order', 'srid']
    model = models.SpatialReferenceSystem


admin_site.register(models.SpatialReferenceSystem, SpatialReferenceSystemAdmin)


class ItemKeyAdmin(admin.ModelAdmin):
    list_display = ('content_type', 'key', 'content_object', 'importer')
    search_fields = ('key', )


admin_site.register(models.ItemKey, ItemKeyAdmin)


class JsonContentTypeFormMixin(object):
    class Meta:
        model = models.JsonDataSection
        exclude = []

    def __init__(self, *args, **kwargs):
        super(JsonContentTypeFormMixin, self).__init__(*args, **kwargs)
        choices = []
        for pk, label in self.fields['content_type'].choices:
            if not pk:
                choices.append((pk, label))
                continue
            ct = ContentType.objects.get(pk=pk)
            model_class = ct.model_class()
            if hasattr(model_class, 'data') and \
                    not hasattr(model_class, 'history_type'):
                choices.append((pk, label))
        self.fields['content_type'].choices = sorted(choices,
                                                     key=lambda x: x[1])


class JsonDataSectionForm(JsonContentTypeFormMixin, forms.ModelForm):
    class Meta:
        model = models.JsonDataSection
        exclude = []


class JsonDataSectionAdmin(admin.ModelAdmin):
    list_display = ['name', 'content_type', 'order']
    form = JsonDataSectionForm


admin_site.register(models.JsonDataSection, JsonDataSectionAdmin)


class JsonDataFieldForm(JsonContentTypeFormMixin, forms.ModelForm):
    class Meta:
        model = models.JsonDataField
        exclude = []


class JsonDataFieldAdmin(admin.ModelAdmin):
    list_display = ['name', 'content_type', 'key', 'display',
                    'order', 'section']
    form = JsonDataFieldForm


admin_site.register(models.JsonDataField, JsonDataFieldAdmin)


def get_choices_form():
    cache_key, value = get_cache(models.CustomForm, ['associated-forms'])
    if value:
        return value
    forms = []
    for slug in models.CustomForm.register():
        forms.append((slug, models.CustomForm._register[slug].form_admin_name))
    forms = sorted(forms, key=lambda x: x[1])
    cache.set(cache_key, forms, settings.CACHE_TIMEOUT)
    return forms


class CustomFormForm(forms.ModelForm):
    class Meta:
        model = models.CustomForm
        exclude = []
    form = forms.ChoiceField(label=_(u"Form"), choices=get_choices_form)
    users = AutoCompleteSelectMultipleField('ishtaruser', required=False,
                                            label=_(u"Users"))


class ExcludeFieldFormset(BaseInlineFormSet):
    def get_form_kwargs(self, index):
        kwargs = super(ExcludeFieldFormset, self).get_form_kwargs(index)
        if not self.instance or not self.instance.pk:
            return kwargs
        form = self.instance.get_form_class()
        if not form:
            kwargs['choices'] = []
            return kwargs
        kwargs['choices'] = [('', '--')] + form.get_custom_fields()
        return kwargs


class ExcludeFieldForm(forms.ModelForm):
    class Meta:
        model = models.ExcludedField
        exclude = []
    field = forms.ChoiceField(label=_(u"Field"))

    def __init__(self, *args, **kwargs):
        choices = kwargs.pop('choices')
        super(ExcludeFieldForm, self).__init__(*args, **kwargs)
        self.fields['field'].choices = choices


class ExcludeFieldInline(admin.TabularInline):
    model = models.ExcludedField
    extra = 2
    form = ExcludeFieldForm
    formset = ExcludeFieldFormset


class CustomFormAdmin(admin.ModelAdmin):
    list_display = ['name', 'form', 'available', 'apply_to_all',
                    'users_lbl', 'user_types_lbl']
    fields = ('name', 'form', 'available', 'apply_to_all', 'users',
              'user_types')
    form = CustomFormForm
    inlines = [ExcludeFieldInline]

    def get_inline_instances(self, request, obj=None):
        # no inline on creation
        if not obj:
            return []
        return super(CustomFormAdmin, self).get_inline_instances(request,
                                                                 obj=obj)

    def get_readonly_fields(self, request, obj=None):
        if obj:
            return ('form',)
        return []


admin_site.register(models.CustomForm, CustomFormAdmin)


class AdministrationScriptAdmin(admin.ModelAdmin):
    list_display = ['name', 'path']

    def get_readonly_fields(self, request, obj=None):
        if obj:
            return ('path',)
        return []


admin_site.register(models.AdministrationScript, AdministrationScriptAdmin)


class ImageAdmin(admin.ModelAdmin):
    list_display = ('name', 'image_type', 'reference', 'internal_reference')
    list_filter = ('image_type',)
    search_fields = ('name', 'reference', 'internal_reference')


admin_site.register(models.IshtarImage, ImageAdmin)


class AdministrationTaskAdmin(admin.ModelAdmin):
    readonly_fields = ('state', 'creation_date', 'launch_date',
                       'finished_date', "result", )
    list_display = ['script', 'state', 'creation_date', 'launch_date',
                    'finished_date', "result"]
    list_filter = ['script', 'state']

    def get_readonly_fields(self, request, obj=None):
        if obj:
            return ("script", ) + self.readonly_fields
        return self.readonly_fields


admin_site.register(models.AdministrationTask, AdministrationTaskAdmin)


basic_models = [models.DocumentTemplate]

for model in basic_models:
    admin_site.register(model)