diff --git a/assets/src/services/requests/Condition.js b/assets/src/services/requests/Condition.js
index 4baf3bf7..36487b18 100644
--- a/assets/src/services/requests/Condition.js
+++ b/assets/src/services/requests/Condition.js
@@ -1,56 +1,56 @@
 import Api from '../Api'
 
 let today = new Date().toISOString().slice(0, 10)
 var date_filter = 'ge(journalcondition.valid_until,' + today +
   '),le(journalcondition.valid_from,' + today +
   '),ge(organizationcondition.valid_until,' + today +
   '),le(organizationcondition.valid_from,' + today + ')'
 // To stop filtering by validity dates, replace by a trivial filter such as
 // var date_filter = 'ge(condition.id,0)'
 
 export const getCondition = (id) => {
   return Api.request({
     url: `/conditionterm/${id}`,
     method: 'GET',
   })
 }
 export const getListOfCondition = () => {
   return Api.request({
     url: `/conditionterm/`,
     method: 'GET',
   })
 }
 export const searchCondi = (journalId,institId) => {
   return Api.request({
-    url: `/conditionset/?and(eq(journalcondition.journal.id,${journalId}),eq(organizationcondition.organization.id,${institId}),${date_filter})`,
+    url: `/conditionset_light/?and(eq(journalcondition.journal.id,${journalId}),eq(organizationcondition.organization.id,${institId}),${date_filter})`,
     method: 'GET',
   })
 }
 
 export const searchInstitFunder = (institId,funderId,condi) => {
   return Api.request({
-    url: `/conditionset/?(eq(organizationcondition.organization.id,${institId})|eq(organizationcondition.organization.id,${funderId}))&ne(condition_type.id,${condi})&and(${date_filter})`,
+    url: `/conditionset_light/?(eq(organizationcondition.organization.id,${institId})|eq(organizationcondition.organization.id,${funderId}))&ne(condition_type.id,${condi})&and(${date_filter})`,
     method: 'GET',
   })
 }
 
 export const searchCondi3 = (institId,journalId,funderId) => {
   return Api.request({
-    url: `/conditionset/?(eq(organizationcondition.organization.id,${institId})|eq(organizationcondition.organization.id,${funderId}))&eq(journalcondition.journal.id,${journalId})&and(${date_filter})`,
+    url: `/conditionset_light/?(eq(organizationcondition.organization.id,${institId})|eq(organizationcondition.organization.id,${funderId}))&eq(journalcondition.journal.id,${journalId})&and(${date_filter})`,
     method: 'GET',
   })
 }
 
 export const searchorganizationonly = (id,condi) => {
   return Api.request({
-    url: `/conditionset/?and(eq(organizationcondition.organization.id,${id}),ne(condition_type.id,${condi}),${date_filter})`,
+    url: `/conditionset_light/?and(eq(organizationcondition.organization.id,${id}),ne(condition_type.id,${condi}),${date_filter})`,
     method: 'GET',
   })
 }
 
 export const searchjournalonly = (id,condi) => {
   return Api.request({
-    url: `/conditionset/?and(eq(journalcondition.journal.id,${id}),ne(condition_type.id,${condi}),${date_filter})`,
+    url: `/conditionset_light/?and(eq(journalcondition.journal.id,${id}),ne(condition_type.id,${condi}),${date_filter})`,
     method: 'GET',
   })
 }
\ No newline at end of file
diff --git a/django_api/serializers.py b/django_api/serializers.py
index 21e21300..152c8ba3 100644
--- a/django_api/serializers.py
+++ b/django_api/serializers.py
@@ -1,191 +1,217 @@
 from rest_framework import serializers
 
 from dj_rql.drf.serializers import RQLMixin
 from .models import *
 from drf_writable_nested.serializers import WritableNestedModelSerializer
 
 
 class CountrySerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
 
     class Meta:
         model = Country
         fields = '__all__'
         depth = 4
 
 
 class LanguageSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
 
     class Meta:
         model = Language
         fields = '__all__'
         depth = 4
 
 
 class PublisherSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
     country = CountrySerializer(required=False, many=True)
 
     class Meta:
         model = Publisher
         fields = '__all__'
         depth = 4
 
 
 class OaSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False, allow_null=True)
 
     class Meta:
         model = Oa
         fields = '__all__'
         depth = 4
 
 
 class IssnSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
 
     class Meta:
         model = Issn
         fields = '__all__'
         depth = 1
 
 
 class JournalSerializer(WritableNestedModelSerializer, RQLMixin):
     id = serializers.IntegerField(required=False)
     issn = IssnSerializer(required=False, source='classIssn', many=True)
     publisher = PublisherSerializer(required=False, many=True)
     language = LanguageSerializer(required=False, many=True)
     # allow update via post request --> "oa_status": {2},
     # oa_status = serializers.PrimaryKeyRelatedField(queryset=Oa.objects.all())
     oa_status = OaSerializer(required=False,allow_null=True)
 
     class Meta:
         model = Journal
         fields = '__all__'
         depth = 4
 
 
 class LicenceSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
 
     class Meta:
         model = Licence
         fields = '__all__'
         depth = 4
 
 
 class Cost_factor_typeSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
 
     class Meta:
         model = Cost_factor_type
         fields = '__all__'
         depth = 4
 
 
 class VersionSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
 
     class Meta:
         model = Version
         fields = '__all__'
         depth = 4
 
 
 class OrgaSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
     country = CountrySerializer(required=False, many=True)
     
     class Meta:
         model = Organization
         fields = '__all__'
         depth = 4
 
 
 class Cost_factorSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
     cost_factor_type = Cost_factor_typeSerializer(required=False, allow_null=True)
 
     class Meta:
         model = Cost_factor
         fields = '__all__'
         depth = 4
 
 
 class TermSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
     version = VersionSerializer(required=False, many=True)
     cost_factor = Cost_factorSerializer(required=False, many=True)
     licence = LicenceSerializer(required=False, many=True)
 
     class Meta:
         model = Term
         fields = '__all__'
         depth = 4
 
 
 class ConditionTypeSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
 
     class Meta:
         model = ConditionType
         fields = '__all__'
         depth = 4
 
 
 class ConditionSetSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
     term = TermSerializer(many=True, read_only=False)
     condition_type = ConditionTypeSerializer(read_only=False)
     organization = OrgaSerializer(many=True, read_only=False)
     journal = JournalSerializer(many=True, read_only=False)
 
     class Meta:
         model = ConditionSet
         # pre filter for rql
         # fields = ['id','condition_type','term','journal','organization']
         # add for informations purpose
         fields = '__all__'
         depth = 4
 
 
+class JournalIdSerializer(WritableNestedModelSerializer,RQLMixin):
+    id = serializers.IntegerField(required=False)
+    # allow update via post request --> "oa_status": {2},
+
+    class Meta:
+        model = Journal
+        fields = ['id']
+        
+
+class ConditionSetLightSerializer(WritableNestedModelSerializer,RQLMixin):
+    id = serializers.IntegerField(required=False)
+    term = TermSerializer(many=True, read_only=False)
+    condition_type = ConditionTypeSerializer(read_only=False)
+    organization = OrgaSerializer(many=True, read_only=False)
+    # No journals in this one.
+    journal = JournalIdSerializer(many=True, read_only=False)
+
+    class Meta:
+        model = ConditionSet
+        # pre filter for rql
+        # fields = ['id','condition_type','term','journal','organization']
+        # add for informations purpose
+        fields = ['id', 'condition_type', 'term', 'organization', 'journal']
+        depth = 4
+
+
 class JournalLightSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
     # allow update via post request --> "oa_status": {2},
     oa_status = serializers.PrimaryKeyRelatedField(queryset=Oa.objects.all())
 
     class Meta:
         model = Journal
         fields = ['id', 'name', 'oa_status']
         depth = 1
 
 
 class OaSerializer(WritableNestedModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
 
     class Meta:
         model = Oa
         fields = '__all__'
         depth = 4
 
 
 class OrganizationConditionSerializer(serializers.ModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
     organization = OrgaSerializer(required=False)
     condition_set = ConditionSetSerializer(required=False)
 
     class Meta:
         model = OrganizationCondition
         fields = '__all__'
         depth = 4
 
 
 class JournalConditionSerializer(serializers.ModelSerializer,RQLMixin):
     id = serializers.IntegerField(required=False)
     journal = JournalSerializer(required=False)
     condition_set = ConditionSetSerializer(required=False)
     class Meta:
         model = JournalCondition
         fields = '__all__'
         depth = 4
diff --git a/django_api/urls.py b/django_api/urls.py
index 9bddbe75..c1e15ddc 100644
--- a/django_api/urls.py
+++ b/django_api/urls.py
@@ -1,37 +1,39 @@
 from django.urls import path, re_path, include
 from django.conf.urls.static import static
 from django.conf import settings
 from .views import *
 from rest_framework import routers
 from rest_framework.schemas import get_schema_view
 
 router = routers.DefaultRouter()
 router.register(r'journal', JournalViewSet)
 router.register(r'journal_light', JournalLightViewSet)
 router.register(r'organization', OrgaViewSet)
 router.register(r'funder', FunderViewSet)
 router.register(r'conditionset', ConditionSetViewSet)
+router.register(r'conditionset_light', ConditionSetLightViewSet)
 router.register(r'term', TermViewSet)
 
 # show table details in the API
 router.register(r'country', CountryViewSet)
 router.register(r'language', LanguageViewSet)
 router.register(r'issn', IssnViewSet)
 router.register(r'oa', OaViewSet)
 router.register(r'publisher', PublisherViewSet)
 router.register(r'version', VersionViewSet)
 router.register(r'licence', LicenceViewSet)
 router.register(r'cost_factor_type', Cost_factor_typeViewSet)
 router.register(r'cost_factor', Cost_factorViewSet)
 router.register(r'conditiontype', ConditionTypeViewSet)
 router.register(r'JournalCondition', JournalConditionViewSet)
 router.register(r'organizationCondition', OrganizationConditionViewSet)
 
+
 urlpatterns = [
     path('', include(router.urls)),
     path('openapi', get_schema_view(
         title="OACCT API",
         description="API of the Open Access Compliance Check Tool (OACCT)",
         version ="0.0.1"
     ), name='openapi-schema'),
 ]
diff --git a/django_api/views.py b/django_api/views.py
index e0b2f241..f4677c79 100644
--- a/django_api/views.py
+++ b/django_api/views.py
@@ -1,225 +1,233 @@
 
 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 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 itertools import chain
 
 from django.db.models import Count
 
 from dj_rql.filter_cls import RQLFilterClass
 
 
 from urllib.parse import unquote
 from datetime import date
 
 
 class JournalViewSet(viewsets.ModelViewSet):
     authentification_classes = (BasicAuthentication,)
     permission_classes = [IsAuthenticatedOrReadOnly]
     search_fields = ['name']
     filter_backends = (filters.SearchFilter,)
 
     queryset = Journal.objects.all()
     serializer_class = JournalSerializer
 
 class JournalLightViewSet(viewsets.ModelViewSet):
     authentification_classes = (BasicAuthentication,)
     permission_classes = [IsAuthenticatedOrReadOnly]
     search_fields = ['name']
     filter_backends = (filters.SearchFilter,)
 
     queryset = Journal.objects.all()
     serializer_class = JournalLightSerializer
 
 
 class OrgaViewSet(viewsets.ModelViewSet):
     authentification_classes = (BasicAuthentication,)
     permission_classes = [IsAuthenticatedOrReadOnly]
     serializer_class =  OrgaSerializer
     queryset = Organization.objects.filter(
         is_funder=False
     )
 
 
 class ConditionSetFilters(RQLFilterClass):
     #Frontend api 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 ConditionSetViewSet(viewsets.ModelViewSet):
     authentification_classes = (BasicAuthentication,)
     permission_classes = [IsAuthenticatedOrReadOnly]
     queryset = ConditionSet.objects.all()
     # queryset = ConditionSet.objects.values('term__version__description')
     serializer_class = ConditionSetSerializer
     # serializer_class = ConditionGroupedSerializer
     rql_filter_class = ConditionSetFilters
 
     #.objects.values('term__version.description')
 
 
+class ConditionSetLightViewSet(viewsets.ModelViewSet):
+    authentification_classes = (BasicAuthentication,)
+    permission_classes = [IsAuthenticatedOrReadOnly]
+    queryset = ConditionSet.objects.all()
+    serializer_class = ConditionSetLightSerializer
+    rql_filter_class = ConditionSetFilters
+
+
 class FunderViewSet(viewsets.ModelViewSet):
     authentification_classes = (BasicAuthentication,)
     permission_classes = [IsAuthenticatedOrReadOnly]
     serializer_class = OrgaSerializer
     queryset = Organization.objects.filter(
         is_funder=True
     )
 
 
 class TermViewSet(viewsets.ModelViewSet):
     authentification_classes = (BasicAuthentication,)
     permission_classes = [IsAuthenticatedOrReadOnly]
     serializer_class = TermSerializer
     queryset = Term.objects.all()
 
 
 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 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()
 
 
 # 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')) 
\ No newline at end of file