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

rOACCT/django_api/views.py
c19147ea74e9issn4frontend

Last Change
Raw File

views.py
View Options

"""
This is the Open Access Check Tool (OACT).
The publication of scientific articles as Open Access (OA), usually in the variants "Green OA" and "Gold OA", allows free access to scientific research results and their largely unhindered dissemination. Often, however, the multitude of available publication conditions makes the decision in favor of a particular journal difficult: requirements of the funding agencies and publication guidelines of the universities and colleges must be carefully compared with the offers of the publishing houses, and separately concluded publication agreements can also offer additional benefits. The "OA Compliance Check Tool" provides a comprehensive overview of the possible publication conditions for a large number of journals, especially for the Swiss university landscape, and thus supports the decision-making process.
© All rights reserved. ECOLE POLYTECHNIQUE FEDERALE DE LAUSANNE, Switzerland, Scientific Information and Libraries, 2022
See LICENSE.TXT for more details.
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
<https://www.gnu.org/licenses/>.
"""
from django.contrib.auth.models import AbstractUser
from django.shortcuts import render
from django.contrib.auth import authenticate, login, logout
from django.shortcuts import render
from django.http import HttpResponse, HttpResponseRedirect, Http404, JsonResponse
from .models import *
from .serializers import *
from rest_framework import viewsets, filters, generics
from django.utils.decorators import method_decorator
from django.views.decorators.cache import cache_page
from rest_framework.authentication import BasicAuthentication
from rest_framework.permissions import IsAuthenticatedOrReadOnly
from rest_framework import status
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework_tracking.mixins import LoggingMixin
from itertools import chain
from django.db.models import Count, Max
from dj_rql.filter_cls import RQLFilterClass, AutoRQLFilterClass
from urllib.parse import unquote
from datetime import date
import ipaddress
class JournalFilters(AutoRQLFilterClass):
# TODO accept ISSN values as filter fields
MODEL = Journal
"""
DISTINCT = True
FILTERS = (
'id',
'oa_status',
'name',
)
"""
class JournalViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
#search_fields = ['name']
filter_backends = (filters.SearchFilter,)
rql_filter_class = JournalFilters
queryset = Journal.objects.all()
serializer_class = JournalSerializer
class JournalLightViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
#search_fields = ['name']
filter_backends = (filters.SearchFilter,)
rql_filter_class = JournalFilters
queryset = Journal.objects.all().prefetch_related('publisher', 'language', 'oa_status')
serializer_class = JournalLightSerializer
@method_decorator(cache_page(4 * 60 * 60))
def dispatch(self, request, *args, **kwargs):
# print('dispatch() called')
return super().dispatch(request, *args, **kwargs)
@method_decorator(cache_page(4 * 60 * 60))
def list(self, request):
# print('list() called')
serializer = self.serializer_class(self.queryset, many=True)
return Response(serializer.data)
class OrganizationFilters(RQLFilterClass):
MODEL = Organization
DISTINCT = True
FILTERS = (
'id',
'ror'
)
class OrgaViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = OrgaSerializer
queryset = Organization.objects.filter(
is_funder=False
)
search_fields = ['id', 'ror']
rql_filter_class = OrganizationFilters
class ConditionSetFilters(RQLFilterClass):
""" API filters for the essential query on ConditionSets
Arguments can include a journal id, zero to two organization ids,
validity dates and a condition type.
Request examples:
http://127.0.0.1:8000/api/conditionset/?and(eq(journalcondition.journal.id,3),eq(organizationcondition.organization.id,11),eq(condition_type.id,1))
http://127.0.0.1:8000/api/conditionset/?and(eq(journalcondition.journal.id,14),ne(condition_type.id,2),ge(journalcondition.valid_until,2021-08-20),le(journalcondition.valid_from,2021-08-20),ge(organizationcondition.valid_until,2021-08-20),le(organizationcondition.valid_from,2021-08-20))
"""
MODEL = ConditionSet
DISTINCT = True
FILTERS = (
'id',
{
'namespace': 'journalcondition',
'filters': ['id', 'valid_from', 'valid_until',
{
'namespace': 'journal',
'filters': ['id', ],
}
],
},
{
'namespace': 'organizationcondition',
'filters': ['id', 'valid_from', 'valid_until',
{
'namespace': 'organization',
'filters': ['id', ]
}
],
},
{
'namespace': 'condition_type',
'filters': ['id', ],
},
)
class JournalConditionFilters(RQLFilterClass):
MODEL = JournalCondition
FILTERS = (
'id',
{
'namespace': 'condition_set',
'filters': ['id', ],
},
{
'namespace': 'journal',
'filters': ['id', ],
},
)
class OrganizationConditionFilters(RQLFilterClass):
MODEL = OrganizationCondition
FILTERS = (
'id',
{
'namespace': 'condition_set',
'filters': ['id', ],
},
{
'namespace': 'organization',
'filters': ['id', ],
},
)
class MyLoggingMixin(LoggingMixin):
"""
Supercharge drf_tracking.LoggingMixin to get the real IP address in the OpenShift infrastructure
"""
def _get_ip_address(self, request):
"""Get the remote ip address the request was generated from."""
# print(request.META)
ipaddr = request.META.get("X-Real-IP", None)
if ipaddr:
ipaddr = ipaddr.split(",")[0]
else:
ipaddr = request.META.get("HTTP_X_FORWARDED_FOR", None)
if ipaddr:
ipaddr = ipaddr.split(",")[0]
else:
ipaddr = request.META.get("REMOTE_ADDR", "").split(",")[0]
# Account for IPv4 and IPv6 addresses, each possibly with port appended. Possibilities are:
# <ipv4 address>
# <ipv6 address>
# <ipv4 address>:port
# [<ipv6 address>]:port
# Note that ipv6 addresses are colon separated hex numbers
possibles = (ipaddr.lstrip("[").split("]")[0], ipaddr.split(":")[0])
for addr in possibles:
try:
return str(ipaddress.ip_address(addr))
except ValueError:
pass
return ipaddr
class ConditionSetViewSet(MyLoggingMixin, viewsets.ModelViewSet):
""" ViewSet for ConditionSets
The QuerySet obtained from the database is annotated to obtain the desired sorting order,
i.e. by condition_type, then subtype, then a calculated score so that institutions receive
more attention than funders within a given type/subtype
"""
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
queryset = ConditionSet.objects.all().annotate(include_funder=Max('organization__is_funder')).order_by('condition_type','subtype', 'include_funder','comment')
# queryset = ConditionSet.objects.values('term__version__description')
serializer_class = ConditionSetSerializer
# serializer_class = ConditionGroupedSerializer
rql_filter_class = ConditionSetFilters
#.objects.values('term__version.description')
class ConditionSetLightViewSet(MyLoggingMixin, viewsets.ModelViewSet):
""" Light-weight ViewSet for ConditionSets
The QuerySet obtained from the database is annotated to obtain the desired sorting order,
i.e. by condition_type, then subtype, then a calculated score so that institutions receive
more attention than funders within a given type/subtype
"""
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
queryset = ConditionSet.objects.all().annotate(include_funder=Max('organization__is_funder')).order_by('condition_type','subtype','include_funder','comment')
serializer_class = ConditionSetLightNewSerializer
rql_filter_class = ConditionSetFilters
class ConditionSetMiniViewSet(MyLoggingMixin, viewsets.ModelViewSet):
""" Light-weight ViewSet for ConditionSets
The QuerySet obtained from the database is annotated to obtain the desired sorting order,
i.e. by condition_type, then subtype, then a calculated score so that institutions receive
more attention than funders within a given type/subtype
"""
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
queryset = ConditionSet.objects.all()
serializer_class = ConditionSetMiniSerializer
rql_filter_class = ConditionSetFilters
class FunderViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = OrgaSerializer
queryset = Organization.objects.filter(
is_funder=True
)
rql_filter_class = OrganizationFilters
class TermFilters(RQLFilterClass):
MODEL = Term
FILTERS = (
'id',
)
class TermViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = TermSerializer
queryset = Term.objects.all()
rql_filter_class = TermFilters
class TermLightViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = TermLightSerializer
queryset = Term.objects.all()
rql_filter_class = TermFilters
class CountryViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = CountrySerializer
queryset = Country.objects.all()
class LanguageViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = LanguageSerializer
queryset = Language.objects.all()
class IssnViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = IssnSerializer
queryset = Issn.objects.all()
class OaViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = OaSerializer
queryset = Oa.objects.all()
class PublisherViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = PublisherSerializer
queryset = Publisher.objects.all()
class VersionViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = VersionSerializer
queryset = Version.objects.all()
class LicenceViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = LicenceSerializer
queryset = Licence.objects.all()
class Cost_factor_typeViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = Cost_factor_typeSerializer
queryset = Cost_factor_type.objects.all()
class Cost_factorViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = Cost_factorSerializer
queryset = Cost_factor.objects.all()
class Cost_factorLightViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = Cost_factorLightSerializer
queryset = Cost_factor.objects.all()
class ConditionTypeViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = ConditionTypeSerializer
queryset = ConditionType.objects.all()
class OrganizationConditionViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = OrganizationConditionSerializer
queryset = OrganizationCondition.objects.all()
class JournalConditionViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = JournalConditionSerializer
queryset = JournalCondition.objects.all()
class OrganizationConditionViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = OrganizationConditionSerializer
queryset = OrganizationCondition.objects.all()
class JournalConditionBasicViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = JournalConditionBasicSerializer
rql_filter_class = JournalConditionFilters
queryset = JournalCondition.objects.all()
def create(self, request, *args, **kwargs):
many = True if isinstance(request.data, list) else False
serializer = self.get_serializer(data=request.data, many=many)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
class OrganizationConditionBasicViewSet(viewsets.ModelViewSet):
authentification_classes = (BasicAuthentication,)
permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = OrganizationConditionBasicSerializer
rql_filter_class = OrganizationConditionFilters
queryset = OrganizationCondition.objects.all()
def create(self, request, *args, **kwargs):
many = True if isinstance(request.data, list) else False
serializer = self.get_serializer(data=request.data, many=many)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
# Count number of different version
# OrganizationCondition.objects.annotate(version_count=Count('condition_set__term__version'))
# OrganizationCondition.objects
# .values('condition_set__term__version') #what to group by
# .annotate(version_count=Count('condition_set__term__version')) # what to aggregate
# group by version and count
# OrganizationCondition.objects.values('condition_set__term__version').annotate(version_count=Count('condition_set__term__version'))
# source https://hakibenita.com/django-group-by-sql
# https://docs.djangoproject.com/en/3.2/topics/db/aggregation/
# OrganizationCondition.objects.values('condition_set__term__version').filter(organization_id=1).annotate(version_count=Count('condition_set__term__version'))
c4science · Help