Homec4science
Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

rOACCT/django_api/admin.py
272eac9334f3issn4frontend

Last Change
Raw File

admin.py
View Options

from django.contrib import admin
from datetime import date
from import_export.admin import ImportExportModelAdmin
from django.contrib.admin import TabularInline, SimpleListFilter
from django.utils.translation import gettext_lazy as _
#from inline_actions.admin import InlineActionsMixin
#from inline_actions.admin import InlineActionsModelAdminMixin
from django.shortcuts import render
from django.http import HttpResponseRedirect
from .models import Country
from .models import Language
from .models import Issn
from .models import Oa
from .models import Publisher
from .models import Journal
from .models import Organization
from .models import Version
from .models import Licence
from .models import Cost_factor_type
from .models import Cost_factor
from .models import Term
from .models import ConditionType
from .models import ConditionSet
from .models import OrganizationCondition
from .models import JournalCondition
# Register your models here.
@admin.register(Journal)
class JournalAdmin(ImportExportModelAdmin):
list_display = ("id", "name", "journal_issns",)
list_filter = ('publisher__name', 'oa_status')
filter_horizontal = ('publisher', 'language', )
def journal_issns(self, obj):
# TBD
pass
@admin.register(Language)
class LanguageAdmin(ImportExportModelAdmin):
pass
@admin.register(Organization)
class OrganizationAdmin(ImportExportModelAdmin):
list_display = ("id", "name")
list_filter = ('is_funder',)
filter_horizontal = ('country', )
@admin.register(Version)
class VersionAdmin(ImportExportModelAdmin):
pass
@admin.register(Country)
class CountryAdmin(ImportExportModelAdmin):
pass
@admin.register(Issn)
class IssnAdmin(ImportExportModelAdmin):
list_filter = ('issn_type', )
@admin.register(Oa)
class OaAdmin(ImportExportModelAdmin):
pass
@admin.register(Publisher)
class PublisherAdmin(ImportExportModelAdmin):
list_display = ("id", "name")
# Experimental: what will happen with 200+ countries in the database?
list_filter = ('country__name', )
filter_horizontal = ('country', )
@admin.register(Term)
class TermAdmin(ImportExportModelAdmin):
list_filter = ('version', 'licence')
filter_horizontal = ('version', 'cost_factor', 'licence', )
@admin.register(ConditionType)
class ConditionTypeAdmin(ImportExportModelAdmin):
list_display = ("id", "condition_issuer")
#class JournalConditionInline(InlineActionsMixin, TabularInline):
class JournalConditionInline(TabularInline):
model = JournalCondition
extra = 1
inline_actions = ['connect_all_journals']
def connect_all_journals(self, request, obj, parent_obj=None):
# Do stuff here, then return None to go to current view
return None
connect_all_journals.short_description = ("Connect Condition Set with all Journals")
class OrganizationConditionInline(TabularInline):
#class OrganizationConditionInline(InlineActionsMixin, TabularInline):
model = OrganizationCondition
extra = 1
def connect_with_all_journals(modeladmin, request, queryset):
# print(request.POST)
if request.POST.get('apply'):
try:
valid_from = date.fromisoformat(request.POST['valid_from'])
valid_until = date.fromisoformat(request.POST['valid_until'])
if valid_from > valid_until:
raise ValueError
# print((valid_from, valid_until))
all_journals = Journal.objects.all()
for condition_set in queryset:
# print('-----------------')
# print(condition_set)
for j in all_journals:
# print(j)
# search for existing connections
existing_connections = JournalCondition.objects.filter(journal=j,
condition_set=condition_set,
valid_from__lt=date.today(),
valid_until__gt=date.today())
# print(existing_connections)
if len(existing_connections) == 0:
new_journal_condition = JournalCondition(journal=j,
condition_set=condition_set,
valid_from=valid_from,
valid_until=valid_until)
new_journal_condition.save()
return None
except ValueError:
pass
return render(request, 'admin/get_validity_dates.html', context={'queryset': queryset, 'objects': 'journals'})
connect_with_all_journals.short_description = 'Apply selected condition sets to all Journals'
def connect_with_all_organizations(modeladmin, request, queryset):
# print(request.POST)
if request.POST.get('apply'):
try:
valid_from = date.fromisoformat(request.POST['valid_from'])
valid_until = date.fromisoformat(request.POST['valid_until'])
if valid_from > valid_until:
raise ValueError
# print((valid_from, valid_until))
all_orgs = Organization.objects.all()
for condition_set in queryset:
# print('-----------------')
# print(condition_set)
for o in all_orgs:
# print(o)
# search for existing connections
existing_connections = OrganizationCondition.objects.filter(organization=o,
condition_set=condition_set,
valid_from__lt=date.today(),
valid_until__gt=date.today())
# print(existing_connections)
if len(existing_connections) == 0:
new_organization_condition = OrganizationCondition(organization=o,
condition_set=condition_set,
valid_from=valid_from,
valid_until=valid_until)
new_organization_condition.save()
return None
except ValueError:
pass
return render(request, 'admin/get_validity_dates.html', context={'queryset': queryset, 'objects': 'organizations'})
connect_with_all_organizations.short_description = 'Apply selected condition sets to all Organizations'
@admin.register(ConditionSet)
class ConditionSetAdmin(ImportExportModelAdmin):
# class ConditionSetAdmin(InlineActionsModelAdminMixin, ImportExportModelAdmin):
list_display = ("id", "condition_type", "comment")
search_fields = ['organization__name', 'journal__name', 'comment']
list_filter = ('condition_type', )
filter_horizontal = ('term', )
inlines = (OrganizationConditionInline, JournalConditionInline, )
actions = [connect_with_all_journals, connect_with_all_organizations]
class XConditionValidListFilter(SimpleListFilter):
# Human-readable title which will be displayed in the
# right admin sidebar just above the filter options.
title = _('currently valid')
# Parameter for the filter that will be used in the URL query.
parameter_name = 'valid'
def lookups(self, request, model_admin):
"""
Returns a list of tuples. The first element in each
tuple is the coded value for the option that will
appear in the URL query. The second element is the
human-readable name for the option that will appear
in the right sidebar.
"""
return (
('true', _('True')),
('false', _('False')),
)
def queryset(self, request, queryset):
"""
Returns the filtered queryset based on the value
provided in the query string and retrievable via
`self.value()`.
"""
# Compare the requested value (either '80s' or '90s')
# to decide how to filter the queryset.
if self.value() == 'true':
return queryset.filter(valid_from__lte=date.today(),
valid_until__gte=date.today())
if self.value() == 'false':
return queryset.exclude(valid_from__lte=date.today(),
valid_until__gte=date.today())
@admin.register(OrganizationCondition)
class OrganizationConditionAdmin(ImportExportModelAdmin):
list_display = ("id", "organization_name", "condition_set", "valid_from", "valid_until")
list_filter = ('condition_set__condition_type', XConditionValidListFilter)
def organization_name(self, obj):
return obj.organization.name
@admin.register(Licence)
class LicenceAdmin(ImportExportModelAdmin):
pass
@admin.register(JournalCondition)
class JournalConditionAdmin(ImportExportModelAdmin):
list_display = ("id", "journal_name", "condition_set", "valid_from", "valid_until")
list_filter = ('condition_set__condition_type', XConditionValidListFilter, 'journal__publisher__name')
def journal_name(self, obj):
return obj.journal.name
# unsuccessful attempt
# def formfield_for_foreignkey(self, db_field, request, **kwargs):
# if db_field.name == "journal":
# kwargs["queryset"] = Journal.objects.filter(publisher__name__in=Publisher.objects.order_by().values('name').distinct())
# return super().formfield_for_foreignkey(db_field, request, **kwargs)
@admin.register(Cost_factor)
class Cost_factorAdmin(ImportExportModelAdmin):
list_display = ("id", "comment", "amount", "symbol")
list_filter = ('cost_factor_type', 'symbol')
@admin.register(Cost_factor_type)
class Cost_factor_typeAdmin(ImportExportModelAdmin):
list_display = ("id", "name")
c4science · Help