gmba_django/app/admin.py

from re import A
from unicodedata import name
from django.contrib import admin
from django.utils.html import format_html
from .models import *
from django.forms import TextInput
from django.conf import settings
from django.http import HttpResponse
import csv
from django import forms
from django.contrib.admin.widgets import AutocompleteSelect
from django.contrib import messages  # import messages


class autocomplete_fields_form(forms.ModelForm):
    """This form overrides autocomplete 
    organization field for Person class
    """

    def __init__(self, *args, **kwargs):
        super(autocomplete_fields_form, self).__init__(*args, **kwargs)

        # self.fields['organization'].label = 'My new label'

    class Meta:
        model = Person
        fields = '__all__'
        widgets = {
            'organization': forms.Select(attrs={'style': 'width:750px'})
        }


def download_csv(modeladmin, request, queryset):
    name = queryset[0].__class__.__name__
    response = HttpResponse()
    response['Content-Disposition'] = "attachment; filename="+name+"_table.csv"
    first_row = []
    for i in queryset[0]._meta.__dict__.get("fields"):
        temp = str(i).split('.')
        first_row.append(temp[-1])

    writer = csv.writer(response)
    writer.writerow(first_row)
    for dic in queryset.values():
        temp_list = (list(dic.values()))
        writer.writerow(temp_list)
    return response


download_csv.short_description = 'export (.csv)'


class PeopleResourceInline(admin.TabularInline):
    autocomplete_fields = ['resource']
    model = PeopleResource
    extra = 0


class PeopleRangeInline(admin.TabularInline):
    autocomplete_fields = ['range']
    model = PeopleRange
    extra = 0


class PersonAdmin(admin.ModelAdmin):
    inlines = [
        PeopleResourceInline,
        PeopleRangeInline
    ]
    readonly_fields = ['id']
    search_fields = ['title', 'first_name', 'last_name', 'organisation',
                     'position', 'country__short_name', 'contact_email']
    fieldsets = (
        (None, {
            'fields': (
                ('id', 'profile_on_web', 'news_letter'),
                ('mr_mrs', 'title', 'full_name', 'position'),
                ('first_name', 'last_name', 'search_name', 'status'),
                ('contact_email', 'email_2', 'skype', 'professional_phone'),
                'organization',
                'personal_url',
                'biography',
                'field_of_expertise',
                'geographic_area_of_expertise')
        }),
        ('Research Scale', {
            'classes': ('collapse',),
            'fields': (('field_site', 'transect', 'mountain_top', 'mountain_range', 'landscape', 'regional', 'national',),
                       '_global'),
        }),
        ('Methods and tools', {
            'classes': ('collapse',),
            'fields': (('biological_field_sampling', 'data_mining', 'remote_sensing',
                       'gis', 'spatial_analysis', 'statistical_analysis', 'modelling'),
                       ('assessment', 'meta_analysis', 'synthesis', 'qualitative_ssm', 'genetic_analyses'))
        }),
        ('Taxonomic groups', {
            'classes': ('collapse',),
            'fields': (('birds', 'mammals', 'reptiles', 'amphibians', 'fish', 'insects', 'molluscs', 'crustaceans',
                       'arachnids'), ('angiosperms', 'gymnosperms', 'fungi', 'algae', 'microbes')),
        }),
        ('Others', {
            'classes': ('collapse',),
            'fields': (
                'orcid', 'web_of_science', 'twitter', 'instagram', 'updated',
                'entry_date',
                'country',
                'gmba_function'
            ),
        }),
    )
    list_display = ['id', 'full_name', 'organization']

    #autocomplete_fields = ['organization']
    form = autocomplete_fields_form  # adjust width of autocomplete_fields organization

    list_per_page = settings.ADMIN_LIST_PER_PAGE
    ordering = ['full_name']
    actions = [download_csv]

    def get_field_queryset(self, db, db_field, request):
        queryset = super().get_field_queryset(db, db_field, request)
        if db_field.name == 'organization':
            queryset = queryset.order_by(
                'country', 'organisation_english', 'organisation_2', 'organisation_3', 'acronym')
        return queryset

    def get_actions(self, request):
        actions = super().get_actions(request)
        if 'delete_selected' in actions:
            del actions['delete_selected']
        return actions

    def delete_model(self, request, obj):
        self.delete_person(request, obj)
        return super(PersonAdmin, self).delete_model(request, obj)

    def delete_person(self, request, obj):
        taxa_people = TaxaPeople.objects.filter(person=obj.id)
        for i in taxa_people:
            i.delete()
        ranges_people = RangesPeople.objects.filter(person=obj.id)
        for i in ranges_people:
            i.delete()
        resources_people = ResourcesPeople.objects.filter(person=obj.id)
        for i in resources_people:
            i.delete()
        scales_people = ScalesPeople.objects.filter(person=obj.id)
        for i in scales_people:
            i.delete()
        people_function = PeopleFunction.objects.filter(person=obj.id)
        for i in people_function:
            i.delete()
        people_range = PeopleRange.objects.filter(person=obj.id)
        for i in people_range:
            i.delete()
        people_resources = PeopleResource.objects.filter(person=obj.id)
        for i in people_resources:
            i.delete()
        fields_people = FieldsPeople.objects.filter(person=obj.id)
        for i in fields_people:
            i.delete()
        methods_people = MethodsPeople.objects.filter(person=obj.id)
        for i in methods_people:
            i.delete()

    def delete_persons(self, request, obj):
        for o in obj.all():
            taxa_people = TaxaPeople.objects.filter(person=o.id)
            for i in taxa_people:
                i.delete()
            ranges_people = RangesPeople.objects.filter(person=o.id)
            for i in ranges_people:
                i.delete()
            resources_people = ResourcesPeople.objects.filter(person=o.id)
            for i in resources_people:
                i.delete()
            scales_people = ScalesPeople.objects.filter(person=o.id)
            for i in scales_people:
                i.delete()
            people_function = PeopleFunction.objects.filter(person=o.id)
            for i in people_function:
                i.delete()
            people_range = PeopleRange.objects.filter(person=o.id)
            for i in people_range:
                i.delete()
            people_resources = PeopleResource.objects.filter(person=o.id)
            for i in people_resources:
                i.delete()
            fields_people = FieldsPeople.objects.filter(person=o.id)
            for i in fields_people:
                i.delete()
            methods_people = MethodsPeople.objects.filter(person=o.id)
            for i in methods_people:
                i.delete()
            o.delete()
        messages.success(request, "Successfully deleted")

    delete_persons.short_description = 'Delete Person & Related Fields'

    actions = [download_csv, delete_persons]


class ResourceKeywordInline(admin.TabularInline):
    autocomplete_fields = ['keyword']
    model = ResourceKeyword
    extra = 0


class ResourceRangeInline(admin.TabularInline):
    autocomplete_fields = ['range_name']
    model = ResourceRange
    extra = 0


class ResourcePeopleInline(admin.TabularInline):
    autocomplete_fields = ['person']
    model = PeopleResource
    extra = 0
    formfield_overrides = {
        models.CharField: {'widget': TextInput(attrs={'size': '20'})}
    }


class ResourceAdmin(admin.ModelAdmin):
    inlines = [
        ResourceKeywordInline,
        ResourceRangeInline,
        ResourcePeopleInline
    ]
    search_fields = ['title', 'url', 'citation', 'abstract']
    readonly_fields = ['id']
    list_display = ['title', 'citation', 'type']
    ordering = ['title']
    fieldsets = (
        (None, {
            'fields': (
                ('id', 'stars'),
                'title',
                'citation',
                ('type',),
                ('url',),
                ('lat', 'lon'),
                'doi',
                'wiki_data_id',
                'inventory',
                'abstract',
                'author_keywords'
            )
        }),
        ('Research network', {
            'classes': ('collapse',),
            'fields': (('gloria', 'gnomo', 'lter', 'ltser', 'miren', 'team'),),
        }),

        ('PEGASuS', {
            'classes': ('collapse',),
            'fields': (
                ('PEGASuS_polygon_ID', 'PEGASuS_Polygon_comments', 'PEGASuS_Assessment_ID',
                 'PEGASuS_Check_map_with_author',),)
        }),
    )
    list_per_page = settings.ADMIN_LIST_PER_PAGE

    def get_actions(self, request):
        actions = super().get_actions(request)
        if 'delete_selected' in actions:
            del actions['delete_selected']
        return actions

    def delete_model(self, request, obj):
        self.delete_resource(request, obj)
        return super(ResourceAdmin, self).delete_model(request, obj)

    def delete_resource(self, request, obj):
        resource_keyword = ResourceKeyword.objects.filter(resource=obj.id)
        for i in resource_keyword:
            i.delete()
        resource_range = ResourceRange.objects.filter(resource_title=obj.id)
        for i in resource_range:
            i.delete()
        resource_people = ResourcesPeople.objects.filter(resource=obj.id)
        for i in resource_people:
            i.delete()
        resource_people_resource = PeopleResource.objects.filter(
            resource=obj.id)
        for i in resource_people_resource:
            i.delete()

    def delete_resources(self, request, obj):
        for o in obj.all():
            resource_keyword = ResourceKeyword.objects.filter(resource=o.id)
            for i in resource_keyword:
                i.delete()
            resource_range = ResourceRange.objects.filter(resource_title=o.id)
            for i in resource_range:
                i.delete()
            resource_people = ResourcesPeople.objects.filter(resource=o.id)
            for i in resource_people:
                i.delete()
            resource_people_resource = PeopleResource.objects.filter(
                resource=o.id)
            for i in resource_people_resource:
                i.delete()
            o.delete()
        messages.success(request, "Successfully deleted")
    delete_resources.short_description = 'Delete Resource & Related Fields'

    actions = [download_csv, delete_resources]


class RangeNameTranslationInline(admin.TabularInline):
    autocomplete_fields = ['language_translation']
    model = RangeNameTranslation
    extra = 0


class RangeCountryInline(admin.TabularInline):
    autocomplete_fields = ['country']
    model = RangeCountry
    extra = 0


class RangeAdmin(admin.ModelAdmin):
    autocomplete_fields = ['mother_range']
    # inlines = [
    #     RangeNameTranslationInline,
    #     RangeCountryInline
    # ]
    readonly_fields = ('id', 'gmba_v2_id')
    search_fields = ['name', 'range_name', 'range_name_ascii',
                     'level', 'level', 'level_1', 'level_2', 'level_3', 'peak_name', 'comments', 'source',
                     'name_fr', 'name_de', 'name_es', 'name_pt', 'name_cn', 'name_ru', 'name_tr']
    fieldsets = (
        (None, {
            'fields': (
                ('gmba_v2_id', 'range_name', 'range_name_language'),
                ('map_unit', 'feature', 'gmba_narrow', 'select_300'),
                ('range_name_map', 'range_name_ascii', 'GMBA_v1_id'),
                ('latitude', 'longitude', 'area'),
                ('mother_range', 'countries', 'wiki_data_id', 'wiki_data_url'),
                'source',
                'id',
            )
        }),
        ('Range Name Translation', {
            'classes': ('collapse',),
            'fields': (
                ('name_fr', 'name_de', 'name_es', 'name_pt'),
                ('name_ru', 'name_tr', 'name_cn')
            )
        }),
        ('Comments', {
            'classes': ('collapse',),
            'fields': ('comments',),
        }),
        ('Others', {
            'fields': ('range_alternate_id', )
        })
    )
    list_display = ['range_name', 'mother_range', 'countries']
    ordering = ['range_name']
    list_per_page = settings.ADMIN_LIST_PER_PAGE

    actions = [download_csv]


class PeopleOrganizationInline(admin.TabularInline):
    model = Person
    exclude = ['source_id', 'organisation', 'field_indexer']
    fields = ('title', 'full_name', 'contact_email', 'position')


class OrganizationAdmin(admin.ModelAdmin):
    inlines = [
        PeopleOrganizationInline,
    ]
    readonly_fields = ('org_num1',)
    search_fields = ['organisation_search', 'org_alpha_search',
                     'organisation_2', 'organisation_3', 'subject', 'organisation_english']
    list_display = ['org_num1', 'organisation_english',
                    'organisation_2', 'country']
    fieldsets = (
        (None, {
            'fields': (
                'org_num1',
                ('acronym', 'category', 'subject'),
                'country',
                ('organisation_english', 'tel', 'email', 'url',),
                ('organisation_2', 'organisation_3'),
                'organisation_original',
            )
        }),
        ('Address', {
            'classes': ('collapse',),
            'fields': (
                ('street', 'postcode', 'city'),
                ('po_box', 'lat_long'),
            )
        }),
        ('Other details', {
            'classes': ('collapse',),
            'fields': (
                'tags',
            ),
        })
    )
    ordering = ['organisation_english']
    actions = [download_csv]

    def org_url(self, instance):
        return format_html('<a href="{0}" target="_blank">{1}</a>',
                           str(instance.url).strip("#"),
                           str(instance.url).strip("#"))


class FieldAdmin(admin.ModelAdmin):
    search_fields = ['name']


class CountriesAdmin(admin.ModelAdmin):
    search_fields = ['short_name', 'formal_name', 'membership_within_un_system', 'continent', 'eu_ms', 'eea_ms', 'iso3',
                     'iso2']


class GMBA_SpeciesGroupAdmin(admin.ModelAdmin):
    search_fields = ['species_group']


class LanguageAdmin(admin.ModelAdmin):
    search_fields = ['language']


class PeopleStatusAdmin(admin.ModelAdmin):
    search_fields = ['status']


class RangeTypeAdmin(admin.ModelAdmin):
    search_fields = ['range_type']


class RedListCategoryAdmin(admin.ModelAdmin):
    search_fields = ['red_list_category']


class SourceAdmin(admin.ModelAdmin):
    search_fields = ['source']


class TaxonStatusAdmin(admin.ModelAdmin):
    search_fields = ['taxon_status']


class TaxonUnitAdmin(admin.ModelAdmin):
    search_fields = ['taxon_status']


class TrendsQuantityAdmin(admin.ModelAdmin):
    search_fields = ['trend']


class TrendsQualityAdmin(admin.ModelAdmin):
    search_fields = ['trend']


class RepositoryAdmin(admin.ModelAdmin):
    search_fields = ['repository_name', 'repository_url']


class GMBAFunctionAdmin(admin.ModelAdmin):
    search_fields = ['gmba_function']


class RangeOnlineInfoAdmin(admin.ModelAdmin):
    search_fields = ['info_source']


class PeaksAdmin(admin.ModelAdmin):
    search_fields = ['point_name', 'link']


class SearchAdmin(admin.ModelAdmin):
    search_fields = ['search_string', 'search_date', 'result']
    list_display = ['search_string', 'search_date', 'result']

    def search_string(self, obj):
        return str(obj.search_string) if obj else '--'

    def search_date(self, obj):
        return str(obj.search_date) if obj else '--'

    def result(self, obj):
        return str(obj.result) if obj else '--'


class SpeciesAdmin(admin.ModelAdmin):
    search_fields = ['scientific_name', 'class_', 'english_name', 'url']


class TaxonRangeAdmin(admin.ModelAdmin):
    model = TaxonRange
    search_fields = ['range__range_name', 'taxon',
                     'subrange_or_region', 'distribution', 'source', 'remarks']
    list_display = ['range_name', 'taxon']

    def range_name(self, obj):
        return str(obj.range.range_name) if obj and obj.range and obj.range.range_name else 'None'

    def taxon(self, obj):
        return str(obj.taxon) if obj.taxon else 'None'


class RangeNameTranslationAdmin(admin.ModelAdmin):
    model = RangeNameTranslation
    search_fields = ['range__range_name', 'language__language']
    list_display = ['range_name', 'language_translation']

    def range_name(self, obj):
        return str(obj.range.range_name)

    def country_name(self, obj):
        return str(obj.language.language) if obj.language else 'None'


class PeopleRangeAdmin(admin.ModelAdmin):
    model = MountainRange
    list_display = ['person', 'range_name', ]

    def range_name(self, obj):
        return str(obj.range.name)


class PeopleResourceAdmin(admin.ModelAdmin):
    fields = ('person', 'resource', 'p_r_role')
    list_display = ['person', 'resource', 'role']
    search_fields = ['person__full_name', 'resource__title', 'p_r_role__role']


class SpeciesRangeAdmin(admin.ModelAdmin):
    model = SpeciesRange
    search_fields = ['scientific_name__scientific_name', 'range__range_name']
    list_display = ['scientific_name', 'range_name']

    def scientific_name(self, obj):
        return str(obj.scientific_name.scientific_name) if obj and obj.scientific_name and obj.scientific_name.scientific_name else '--'

    def range_name(self, obj):
        return str(obj.range) if obj.range else '--'


class RangeCountryAdmin(admin.ModelAdmin):
    model = RangeCountry
    search_fields = ['range__range_name', 'country__short_name']
    list_display = ['range_name', 'country_name']

    def range_name(self, obj):
        return str(obj.range.range_name)

    def country_name(self, obj):
        return str(obj.country.short_name) if obj.country else 'None'


class KeywordAdmin(admin.ModelAdmin):
    search_fields = ['keyword']


# Register your models here.
admin.site.register(Person, PersonAdmin)
admin.site.register(Resource, ResourceAdmin)
admin.site.register(MountainRange, RangeAdmin)

admin.site.register(Keyword, KeywordAdmin)
# admin.site.register(Method)
# admin.site.register(Scale)
# admin.site.register(Taxon)
# admin.site.register(Field, FieldAdmin)
admin.site.disable_action('delete_selected')


# LU models
admin.site.register(Country, CountriesAdmin)
# admin.site.register(GMBA_SpeciesGroup, GMBA_SpeciesGroupAdmin)
admin.site.register(Language, LanguageAdmin)
# admin.site.register(PeopleStatus, PeopleStatusAdmin)
# admin.site.register(RangeType, RangeTypeAdmin)
# admin.site.register(RedListCategory, RedListCategoryAdmin)
# admin.site.register(Source, SourceAdmin)
# admin.site.register(TaxonStatus, TaxonStatusAdmin)
# admin.site.register(TaxonUnit, TaxonUnitAdmin)
# admin.site.register(TrendsQuality, TrendsQualityAdmin)
# admin.site.register(TrendsQuantity, TrendsQuantityAdmin)

# Others
# admin.site.register(Repository, RepositoryAdmin)
# admin.site.register(GMBA_function, GMBAFunctionAdmin)
admin.site.register(Organisation, OrganizationAdmin)
# admin.site.register(RangeOnlineInfo, RangeOnlineInfoAdmin)

# admin.site.register(RangeNameTranslation, RangeNameTranslationAdmin)
# admin.site.register(AddElevation)
# admin.site.register(GMBA_V2_Centroid)
# admin.site.register(ImportGeom210915)
# admin.site.register(Peak, PeaksAdmin)
# admin.site.register(Search, SearchAdmin)
# admin.site.register(TaxaPeople)
# # admin.site.register(RangesPeople)
# # admin.site.register(ResourcesPeople)
# admin.site.register(ScalesPeople)
# admin.site.register(Species, SpeciesAdmin)
# admin.site.register(PeopleFunction)
# admin.site.register(SpeciesRange, SpeciesRangeAdmin)
# admin.site.register(RangesPeople, PeopleRangeAdmin)
# admin.site.register(TaxonRange, TaxonRangeAdmin)
# admin.site.register(PeopleResource, PeopleResourceAdmin)
# admin.site.register(RangeCountry, RangeCountryAdmin)