common api

events/filters.py

@@ -0,0 +1,34 @@
+import django_filters
+from .models import Event, EventParticipant, MethodicalFile
+
+class EventFilter(django_filters.FilterSet):
+    name = django_filters.CharFilter(lookup_expr="icontains")
+    location = django_filters.CharFilter(lookup_expr="icontains")
+    date_after = django_filters.DateFilter(field_name="date", lookup_expr="gte")
+    date_before = django_filters.DateFilter(field_name="date", lookup_expr="lte")
+
+    class Meta:
+        model = Event
+        fields = ["name", "location", "date_after", "date_before"]
+
+
+class EventParticipantFilter(django_filters.FilterSet):
+    student_name = django_filters.CharFilter(
+        field_name="student__account__first_name", lookup_expr="icontains"
+    )
+    event_name = django_filters.CharFilter(field_name="event__name", lookup_expr="icontains")
+
+    class Meta:
+        model = EventParticipant
+        fields = ["student_name", "event_name", "points"]
+
+
+class MethodicalFileFilter(django_filters.FilterSet):
+    name = django_filters.CharFilter(lookup_expr="icontains")
+    specialty_name = django_filters.CharFilter(
+        field_name="specialty__name", lookup_expr="icontains"
+    )
+
+    class Meta:
+        model = MethodicalFile
+        fields = ["name", "specialty_name", "upload_date"]

events/serializers.py

@@ -0,0 +1,68 @@
+from rest_framework import serializers
+from .models import (
+    EventStatus,
+    ActivityType,
+    Event,
+    EventOrganizer,
+    EventDetail,
+    EventParticipant,
+    MethodicalFile,
+    RelevantMethodicalFile,
+)
+
+class EventStatusSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = EventStatus
+        fields = "__all__"
+
+
+class ActivityTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ActivityType
+        fields = "__all__"
+
+
+class EventSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Event
+        fields = "__all__"
+
+
+class EventOrganizerSerializer(serializers.ModelSerializer):
+    employee_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = EventOrganizer
+        fields = ["id", "employee", "event", "employee_name"]
+
+    def get_employee_name(self, obj):
+        return f"{obj.employee.account.first_name} {obj.employee.account.last_name}"
+
+
+class EventDetailSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = EventDetail
+        fields = "__all__"
+
+
+class EventParticipantSerializer(serializers.ModelSerializer):
+    student_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = EventParticipant
+        fields = ["id", "student", "event", "points", "student_name"]
+
+    def get_student_name(self, obj):
+        return f"{obj.student.account.last_name} {obj.student.account.first_name}"
+
+
+class MethodicalFileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = MethodicalFile
+        fields = "__all__"
+
+
+class RelevantMethodicalFileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = RelevantMethodicalFile
+        fields = "__all__"

events/urls.py

@@ -0,0 +1,26 @@
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from .views import (
+    EventStatusViewSet,
+    ActivityTypeViewSet,
+    EventViewSet,
+    EventOrganizerViewSet,
+    EventDetailViewSet,
+    EventParticipantViewSet,
+    MethodicalFileViewSet,
+    RelevantMethodicalFileViewSet,
+)
+
+router = DefaultRouter()
+router.register(r"event-statuses", EventStatusViewSet, basename="event-status")
+router.register(r"activity-types", ActivityTypeViewSet, basename="activity-type")
+router.register(r"events", EventViewSet, basename="event")
+router.register(r"event-organizers", EventOrganizerViewSet, basename="event-organizer")
+router.register(r"event-details", EventDetailViewSet, basename="event-detail")
+router.register(r"event-participants", EventParticipantViewSet, basename="event-participant")
+router.register(r"methodical-files", MethodicalFileViewSet, basename="methodical-file")
+router.register(r"relevant-methodical-files", RelevantMethodicalFileViewSet, basename="relevant-methodical-file")
+
+urlpatterns = [
+    path("", include(router.urls)),
+]

events/views.py

@@ -1,3 +1,97 @@
-from django.shortcuts import render
+from rest_framework import viewsets
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django_filters.rest_framework import DjangoFilterBackend
+from .models import (
+    EventStatus,
+    ActivityType,
+    Event,
+    EventOrganizer,
+    EventDetail,
+    EventParticipant,
+    MethodicalFile,
+    RelevantMethodicalFile,
+)
+from .serializers import (
+    EventStatusSerializer,
+    ActivityTypeSerializer,
+    EventSerializer,
+    EventOrganizerSerializer,
+    EventDetailSerializer,
+    EventParticipantSerializer,
+    MethodicalFileSerializer,
+    RelevantMethodicalFileSerializer,
+)
+from .filters import (
+    EventFilter,
+    EventParticipantFilter,
+    MethodicalFileFilter,
+)  # Фильтры будут добавлены позже
 
-# Create your views here.
+class EventStatusViewSet(viewsets.ModelViewSet):
+    queryset = EventStatus.objects.all()
+    serializer_class = EventStatusSerializer
+    filter_backends = [SearchFilter, OrderingFilter]
+    search_fields = ["name"]
+    ordering_fields = ["name"]
+
+
+class ActivityTypeViewSet(viewsets.ModelViewSet):
+    queryset = ActivityType.objects.all()
+    serializer_class = ActivityTypeSerializer
+    filter_backends = [SearchFilter, OrderingFilter]
+    search_fields = ["name"]
+    ordering_fields = ["name"]
+
+
+class EventViewSet(viewsets.ModelViewSet):
+    queryset = Event.objects.all()
+    serializer_class = EventSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_class = EventFilter
+    search_fields = ["name", "location", "description"]
+    ordering_fields = ["date", "name"]
+
+
+class EventOrganizerViewSet(viewsets.ModelViewSet):
+    queryset = EventOrganizer.objects.all()
+    serializer_class = EventOrganizerSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ["employee", "event"]
+    search_fields = ["employee__account__first_name", "employee__account__last_name"]
+    ordering_fields = ["employee", "event"]
+
+
+class EventDetailViewSet(viewsets.ModelViewSet):
+    queryset = EventDetail.objects.all()
+    serializer_class = EventDetailSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ["activity_type", "event"]
+    search_fields = ["activity_type__name"]
+    ordering_fields = ["activity_type", "event"]
+
+
+class EventParticipantViewSet(viewsets.ModelViewSet):
+    queryset = EventParticipant.objects.all()
+    serializer_class = EventParticipantSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_class = EventParticipantFilter
+    search_fields = ["student__account__first_name", "student__account__last_name"]
+    ordering_fields = ["event", "student", "points"]
+
+
+class MethodicalFileViewSet(viewsets.ModelViewSet):
+    queryset = MethodicalFile.objects.all()
+    serializer_class = MethodicalFileSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_class = MethodicalFileFilter
+    search_fields = ["name", "specialty__name"]
+    ordering_fields = ["specialty", "name", "upload_date"]
+
+
+class RelevantMethodicalFileViewSet(viewsets.ModelViewSet):
+    queryset = RelevantMethodicalFile.objects.all()
+    serializer_class = RelevantMethodicalFileSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ["methodical_file", "activity_type"]
+    search_fields = ["methodical_file__name", "activity_type__name"]
+    ordering_fields = ["methodical_file", "activity_type"]

outreach/filters.py

@@ -0,0 +1,25 @@
+import django_filters
+from .models import School, SchoolResponsibility
+
+class SchoolFilter(django_filters.FilterSet):
+    name = django_filters.CharFilter(lookup_expr="icontains")
+    address = django_filters.CharFilter(lookup_expr="icontains")
+    institution_type_name = django_filters.CharFilter(
+        field_name="institution_type__name", lookup_expr="icontains"
+    )
+
+    class Meta:
+        model = School
+        fields = ["name", "address", "institution_type_name"]
+
+
+class SchoolResponsibilityFilter(django_filters.FilterSet):
+    academic_year = django_filters.CharFilter(field_name="academic_year__year", lookup_expr="exact")
+    school_name = django_filters.CharFilter(field_name="school__name", lookup_expr="icontains")
+    responsible_name = django_filters.CharFilter(
+        field_name="responsible__account__first_name", lookup_expr="icontains"
+    )
+
+    class Meta:
+        model = SchoolResponsibility
+        fields = ["academic_year", "school_name", "responsible_name"]

outreach/serializers.py

@@ -0,0 +1,67 @@
+from rest_framework import serializers
+from .models import (
+    InstitutionType,
+    Representative,
+    School,
+    Partner,
+    PartnerRepresentative,
+    SchoolResponsibility,
+)
+
+class InstitutionTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = InstitutionType
+        fields = "__all__"
+
+
+class RepresentativeSerializer(serializers.ModelSerializer):
+    full_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Representative
+        fields = ["id", "first_name", "last_name", "middle_name", "phone", "email", "position", "full_name"]
+
+    def get_full_name(self, obj):
+        return f"{obj.first_name} {obj.last_name}" + (f" {obj.middle_name}" if obj.middle_name else "")
+
+
+class SchoolSerializer(serializers.ModelSerializer):
+    director_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = School
+        fields = ["id", "director", "institution_type", "name", "address", "director_name"]
+
+    def get_director_name(self, obj):
+        if obj.director:
+            return f"{obj.director.first_name} {obj.director.last_name}"
+        return None
+
+
+class PartnerSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Partner
+        fields = "__all__"
+
+
+class PartnerRepresentativeSerializer(serializers.ModelSerializer):
+    representative_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = PartnerRepresentative
+        fields = ["id", "representative", "partner", "representative_name"]
+
+    def get_representative_name(self, obj):
+        return f"{obj.representative.first_name} {obj.representative.last_name}"
+
+
+class SchoolResponsibilitySerializer(serializers.ModelSerializer):
+    responsible_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = SchoolResponsibility
+        fields = ["id", "academic_year", "responsible", "school", "responsible_name"]
+
+    def get_responsible_name(self, obj):
+        return f"{obj.responsible.account.first_name} {obj.responsible.account.last_name}"
+

outreach/urls.py

@@ -0,0 +1,22 @@
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from .views import (
+    InstitutionTypeViewSet,
+    RepresentativeViewSet,
+    SchoolViewSet,
+    PartnerViewSet,
+    PartnerRepresentativeViewSet,
+    SchoolResponsibilityViewSet,
+)
+
+router = DefaultRouter()
+router.register(r"institution-types", InstitutionTypeViewSet, basename="institution-type")
+router.register(r"representatives", RepresentativeViewSet, basename="representative")
+router.register(r"schools", SchoolViewSet, basename="school")
+router.register(r"partners", PartnerViewSet, basename="partner")
+router.register(r"partner-representatives", PartnerRepresentativeViewSet, basename="partner-representative")
+router.register(r"school-responsibilities", SchoolResponsibilityViewSet, basename="school-responsibility")
+
+urlpatterns = [
+    path("", include(router.urls)),
+]

outreach/views.py

@@ -1,3 +1,73 @@
-from django.shortcuts import render
+from rest_framework import viewsets
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django_filters.rest_framework import DjangoFilterBackend
+from .models import (
+    InstitutionType,
+    Representative,
+    School,
+    Partner,
+    PartnerRepresentative,
+    SchoolResponsibility,
+)
+from .serializers import (
+    InstitutionTypeSerializer,
+    RepresentativeSerializer,
+    SchoolSerializer,
+    PartnerSerializer,
+    PartnerRepresentativeSerializer,
+    SchoolResponsibilitySerializer,
+)
+from .filters import (
+    SchoolFilter,
+    SchoolResponsibilityFilter,
+)  # Фильтры будут добавлены позже
 
-# Create your views here.
+class InstitutionTypeViewSet(viewsets.ModelViewSet):
+    queryset = InstitutionType.objects.all()
+    serializer_class = InstitutionTypeSerializer
+    filter_backends = [SearchFilter, OrderingFilter]
+    search_fields = ["name"]
+    ordering_fields = ["name"]
+
+
+class RepresentativeViewSet(viewsets.ModelViewSet):
+    queryset = Representative.objects.all()
+    serializer_class = RepresentativeSerializer
+    filter_backends = [SearchFilter, OrderingFilter]
+    search_fields = ["first_name", "last_name", "position"]
+    ordering_fields = ["position"]
+
+
+class SchoolViewSet(viewsets.ModelViewSet):
+    queryset = School.objects.all()
+    serializer_class = SchoolSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_class = SchoolFilter
+    search_fields = ["name", "address"]
+    ordering_fields = ["institution_type", "name"]
+
+
+class PartnerViewSet(viewsets.ModelViewSet):
+    queryset = Partner.objects.all()
+    serializer_class = PartnerSerializer
+    filter_backends = [SearchFilter, OrderingFilter]
+    search_fields = ["name", "description"]
+    ordering_fields = ["name"]
+
+
+class PartnerRepresentativeViewSet(viewsets.ModelViewSet):
+    queryset = PartnerRepresentative.objects.all()
+    serializer_class = PartnerRepresentativeSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ["representative", "partner"]
+    search_fields = ["representative__first_name", "partner__name"]
+    ordering_fields = ["partner", "representative"]
+
+
+class SchoolResponsibilityViewSet(viewsets.ModelViewSet):
+    queryset = SchoolResponsibility.objects.all()
+    serializer_class = SchoolResponsibilitySerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_class = SchoolResponsibilityFilter
+    search_fields = ["school__name", "responsible__account__first_name"]
+    ordering_fields = ["academic_year", "responsible", "school"]

surveys/filters.py

@@ -0,0 +1,19 @@
+import django_filters
+from .models import QuestionPair, Specialty
+
+class QuestionPairFilter(django_filters.FilterSet):
+    survey_title = django_filters.CharFilter(field_name="survey__title", lookup_expr="icontains")
+    statement_a_text = django_filters.CharFilter(field_name="statement_a__statement", lookup_expr="icontains")
+    statement_b_text = django_filters.CharFilter(field_name="statement_b__statement", lookup_expr="icontains")
+
+    class Meta:
+        model = QuestionPair
+        fields = ["survey_title", "statement_a_text", "statement_b_text"]
+
+
+class SpecialtyFilter(django_filters.FilterSet):
+    institution_name = django_filters.CharFilter(field_name="institution__name", lookup_expr="icontains")
+
+    class Meta:
+        model = Specialty
+        fields = ["name", "institution_name"]

surveys/serializers.py

@@ -0,0 +1,81 @@
+from rest_framework import serializers
+from .models import (
+    Survey,
+    ScoreVariable,
+    Statement,
+    QuestionPair,
+    AgreementQuestion,
+    EducationalInstitution,
+    Profession,
+    Specialty,
+    ProfessionSpecialtyLink,
+    ProfessionTestResult,
+)
+
+class SurveySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Survey
+        fields = "__all__"
+
+
+class ScoreVariableSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ScoreVariable
+        fields = "__all__"
+
+
+class StatementSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Statement
+        fields = "__all__"
+
+
+class QuestionPairSerializer(serializers.ModelSerializer):
+    statement_a_text = serializers.SerializerMethodField()
+    statement_b_text = serializers.SerializerMethodField()
+
+    class Meta:
+        model = QuestionPair
+        fields = ["id", "survey", "statement_a", "statement_b", "statement_a_text", "statement_b_text"]
+
+    def get_statement_a_text(self, obj):
+        return obj.statement_a.statement
+
+    def get_statement_b_text(self, obj):
+        return obj.statement_b.statement
+
+
+class AgreementQuestionSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = AgreementQuestion
+        fields = "__all__"
+
+
+class EducationalInstitutionSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = EducationalInstitution
+        fields = "__all__"
+
+
+class ProfessionSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Profession
+        fields = "__all__"
+
+
+class SurveySpecialtySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Specialty
+        fields = "__all__"
+
+
+class ProfessionSpecialtyLinkSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ProfessionSpecialtyLink
+        fields = "__all__"
+
+
+class ProfessionTestResultSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ProfessionTestResult
+        fields = "__all__"

surveys/urls.py

@@ -0,0 +1,30 @@
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from .views import (
+    SurveyViewSet,
+    ScoreVariableViewSet,
+    StatementViewSet,
+    QuestionPairViewSet,
+    AgreementQuestionViewSet,
+    EducationalInstitutionViewSet,
+    ProfessionViewSet,
+    SpecialtyViewSet,
+    ProfessionSpecialtyLinkViewSet,
+    ProfessionTestResultViewSet,
+)
+
+router = DefaultRouter()
+router.register(r"surveys", SurveyViewSet, basename="survey")
+router.register(r"score-variables", ScoreVariableViewSet, basename="score-variable")
+router.register(r"statements", StatementViewSet, basename="statement")
+router.register(r"question-pairs", QuestionPairViewSet, basename="question-pair")
+router.register(r"agreement-questions", AgreementQuestionViewSet, basename="agreement-question")
+router.register(r"institutions", EducationalInstitutionViewSet, basename="institution")
+router.register(r"professions", ProfessionViewSet, basename="profession")
+router.register(r"specialties", SpecialtyViewSet, basename="specialty")
+router.register(r"profession-specialty-links", ProfessionSpecialtyLinkViewSet, basename="profession-specialty-link")
+router.register(r"profession-test-results", ProfessionTestResultViewSet, basename="profession-test-result")
+
+urlpatterns = [
+    path("", include(router.urls)),
+]

surveys/views.py

@@ -1,3 +1,117 @@
-from django.shortcuts import render
+from rest_framework import viewsets
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django_filters.rest_framework import DjangoFilterBackend
+from .models import (
+    Survey,
+    ScoreVariable,
+    Statement,
+    QuestionPair,
+    AgreementQuestion,
+    EducationalInstitution,
+    Profession,
+    Specialty,
+    ProfessionSpecialtyLink,
+    ProfessionTestResult,
+)
+from .serializers import (
+    SurveySerializer,
+    ScoreVariableSerializer,
+    StatementSerializer,
+    QuestionPairSerializer,
+    AgreementQuestionSerializer,
+    EducationalInstitutionSerializer,
+    ProfessionSerializer,
+    SurveySpecialtySerializer,
+    ProfessionSpecialtyLinkSerializer,
+    ProfessionTestResultSerializer,
+)
+from .filters import (
+    QuestionPairFilter,
+    SpecialtyFilter,
+)  # Фильтры будут добавлены позже
 
-# Create your views here.
+class SurveyViewSet(viewsets.ModelViewSet):
+    queryset = Survey.objects.all()
+    serializer_class = SurveySerializer
+    filter_backends = [SearchFilter, OrderingFilter]
+    search_fields = ["title"]
+    ordering_fields = ["title"]
+
+
+class ScoreVariableViewSet(viewsets.ModelViewSet):
+    queryset = ScoreVariable.objects.all()
+    serializer_class = ScoreVariableSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ["survey"]
+    search_fields = ["name", "title"]
+    ordering_fields = ["survey", "name"]
+
+
+class StatementViewSet(viewsets.ModelViewSet):
+    queryset = Statement.objects.all()
+    serializer_class = StatementSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ["score_variable"]
+    search_fields = ["statement"]
+    ordering_fields = ["statement"]
+
+
+class QuestionPairViewSet(viewsets.ModelViewSet):
+    queryset = QuestionPair.objects.all()
+    serializer_class = QuestionPairSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_class = QuestionPairFilter
+    search_fields = ["statement_a__statement", "statement_b__statement"]
+    ordering_fields = ["survey", "statement_a", "statement_b"]
+
+
+class AgreementQuestionViewSet(viewsets.ModelViewSet):
+    queryset = AgreementQuestion.objects.all()
+    serializer_class = AgreementQuestionSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ["survey", "score_variable"]
+    search_fields = ["question"]
+    ordering_fields = ["survey", "question"]
+
+
+class EducationalInstitutionViewSet(viewsets.ModelViewSet):
+    queryset = EducationalInstitution.objects.all()
+    serializer_class = EducationalInstitutionSerializer
+    filter_backends = [SearchFilter, OrderingFilter]
+    search_fields = ["name"]
+    ordering_fields = ["name"]
+
+
+class ProfessionViewSet(viewsets.ModelViewSet):
+    queryset = Profession.objects.all()
+    serializer_class = ProfessionSerializer
+    filter_backends = [SearchFilter, OrderingFilter]
+    search_fields = ["name"]
+    ordering_fields = ["name"]
+
+
+class SpecialtyViewSet(viewsets.ModelViewSet):
+    queryset = Specialty.objects.all()
+    serializer_class = SurveySpecialtySerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_class = SpecialtyFilter
+    search_fields = ["name", "institution__name"]
+    ordering_fields = ["name", "institution"]
+
+
+class ProfessionSpecialtyLinkViewSet(viewsets.ModelViewSet):
+    queryset = ProfessionSpecialtyLink.objects.all()
+    serializer_class = ProfessionSpecialtyLinkSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ["profession", "specialty"]
+    search_fields = ["profession__name", "specialty__name"]
+    ordering_fields = ["profession", "specialty"]
+
+
+class ProfessionTestResultViewSet(viewsets.ModelViewSet):
+    queryset = ProfessionTestResult.objects.all()
+    serializer_class = ProfessionTestResultSerializer
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ["profession", "survey_score_variable"]
+    search_fields = ["profession__name", "survey_score_variable__title"]
+    ordering_fields = ["profession", "survey_score_variable"]

tisbiProFi/urls.py

@@ -40,6 +40,9 @@ urlpatterns = [
     path('admin/', admin.site.urls),
     path('api/v1/education/', include("education.urls")),
     path('api/v1/employees/', include("employees.urls")),
+    path('api/v1/events/', include("events.urls")),
+    path('api/v1/outreach/', include("outreach.urls")),
+    path('api/v1/surveys/', include("surveys.urls")),
 
     path('docs/swagger<format>/', schema_view.without_ui(cache_timeout=0), name='schema-json'),
     path('docs/swagger/', schema_view.with_ui('swagger', cache_timeout=0), name='schema-swagger-ui'),