From a0a337045b01870947260d9d544b4ff819ff7bcc Mon Sep 17 00:00:00 2001 From: Mikan <72257910+Mikan-DS@users.noreply.github.com> Date: Mon, 19 May 2025 17:10:30 +0300 Subject: [PATCH] common api --- events/filters.py | 34 ++++++++++++ events/serializers.py | 68 +++++++++++++++++++++++ events/urls.py | 26 +++++++++ events/views.py | 98 ++++++++++++++++++++++++++++++++- outreach/filters.py | 25 +++++++++ outreach/serializers.py | 67 +++++++++++++++++++++++ outreach/urls.py | 22 ++++++++ outreach/views.py | 74 ++++++++++++++++++++++++- surveys/filters.py | 19 +++++++ surveys/serializers.py | 81 +++++++++++++++++++++++++++ surveys/urls.py | 30 ++++++++++ surveys/views.py | 118 +++++++++++++++++++++++++++++++++++++++- tisbiProFi/urls.py | 3 + 13 files changed, 659 insertions(+), 6 deletions(-) create mode 100644 events/filters.py create mode 100644 events/serializers.py create mode 100644 events/urls.py create mode 100644 outreach/filters.py create mode 100644 outreach/serializers.py create mode 100644 outreach/urls.py create mode 100644 surveys/filters.py create mode 100644 surveys/serializers.py create mode 100644 surveys/urls.py diff --git a/events/filters.py b/events/filters.py new file mode 100644 index 0000000..98dfa87 --- /dev/null +++ b/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"] diff --git a/events/serializers.py b/events/serializers.py new file mode 100644 index 0000000..e6bafaa --- /dev/null +++ b/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__" \ No newline at end of file diff --git a/events/urls.py b/events/urls.py new file mode 100644 index 0000000..1f22ed8 --- /dev/null +++ b/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)), +] \ No newline at end of file diff --git a/events/views.py b/events/views.py index 91ea44a..eaaa153 100644 --- a/events/views.py +++ b/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"] \ No newline at end of file diff --git a/outreach/filters.py b/outreach/filters.py new file mode 100644 index 0000000..2315de6 --- /dev/null +++ b/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"] \ No newline at end of file diff --git a/outreach/serializers.py b/outreach/serializers.py new file mode 100644 index 0000000..3fe2e00 --- /dev/null +++ b/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}" + diff --git a/outreach/urls.py b/outreach/urls.py new file mode 100644 index 0000000..214a799 --- /dev/null +++ b/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)), +] \ No newline at end of file diff --git a/outreach/views.py b/outreach/views.py index 91ea44a..9b8f1eb 100644 --- a/outreach/views.py +++ b/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"] \ No newline at end of file diff --git a/surveys/filters.py b/surveys/filters.py new file mode 100644 index 0000000..ecee80e --- /dev/null +++ b/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"] \ No newline at end of file diff --git a/surveys/serializers.py b/surveys/serializers.py new file mode 100644 index 0000000..b1c3bfe --- /dev/null +++ b/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__" \ No newline at end of file diff --git a/surveys/urls.py b/surveys/urls.py new file mode 100644 index 0000000..51161cf --- /dev/null +++ b/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)), +] diff --git a/surveys/views.py b/surveys/views.py index 91ea44a..7c1d06a 100644 --- a/surveys/views.py +++ b/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"] \ No newline at end of file diff --git a/tisbiProFi/urls.py b/tisbiProFi/urls.py index b9cf4ac..a6edd51 100644 --- a/tisbiProFi/urls.py +++ b/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/', 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'),