diff --git a/django_api/admin.py b/django_api/admin.py
index 97f7563a..e7bdaf0e 100644
--- a/django_api/admin.py
+++ b/django_api/admin.py
@@ -1,203 +1,237 @@
 from django.contrib import admin
 
 from datetime import date
 
 from import_export.admin import ImportExportModelAdmin
 from django.contrib.admin import TabularInline
 
 #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', )
     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'):
-        print('again')
         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))
+            # print((valid_from, valid_until))
             all_journals = Journal.objects.all()
             for condition_set in queryset:
-                print('-----------------')
-                print(condition_set)
+                # 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)
+                    # 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})
+    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]
-
+    actions = [connect_with_all_journals, connect_with_all_organizations]
 
 
 @admin.register(OrganizationCondition)
 class OrganizationConditionAdmin(ImportExportModelAdmin):
     list_display = ("id", "organization_name", "condition_set", "valid_from", "valid_until")
     list_filter = ('condition_set__condition_type', )
 
     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', )
 
     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")
diff --git a/templates/admin/get_validity_dates.html b/templates/admin/get_validity_dates.html
index b96555c9..423b39a4 100644
--- a/templates/admin/get_validity_dates.html
+++ b/templates/admin/get_validity_dates.html
@@ -1,25 +1,25 @@
 {% extends "admin/base_site.html" %}
 
 {% block content %}
 
 
 <form action="" method="post">
   {% csrf_token %}
   <p>
   Enter the validity dates for the selected conditions:
   </p> 
   From:
   <input name="valid_from" type="date" />
   <br/>
   Until:
   <input name="valid_until" type="date" />
   <br/>
   {% for obj in queryset %}
     <input type="hidden" name="_selected_action" value="{{ obj.pk }}" />
   {% endfor %}
     
-  <input type="hidden" name="action" value="connect_with_all_journals" />
-  <input type="submit" name="apply" value="Set for all journals"/>
+  <input type="hidden" name="action" value="connect_with_all_{{ objects }}" />
+  <input type="submit" name="apply" value="Set for all {{ objects }}"/>
 
 </form>
 {% endblock %}
\ No newline at end of file