Export krb

views.py

import rest_framework.status
from django.shortcuts import get_object_or_404
from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response

from apps.projects.models import Project, StyleTemplate, ProjectLogRecord, ProjectLog
from apps.projects.serializers import ProjectSerializer, StyleTemplateSerializer, ProjectLogRecordSerializer
from core.models import PhysicalObject, PhysicalObjectType, ResearchType, Research, Collection
from core.serializers import CollectionSerializer


class ProjectViewSet(viewsets.ModelViewSet):
    queryset = Project.objects.all()
    serializer_class = ProjectSerializer

    def create_default_collections(self, owner, return_objects=False):
        from .models import Collection
        colls = [
            {
                "name": "Объекты",
                "owner": owner,
                "icon": "https://web-module.dsgrad.devops.lanit-tercom.com/icons/IconCopy_size_s.svg",
                "order": 1
            },
            {
                "name": "Сценарии",
                "owner": owner,
                "icon": "https://web-module.dsgrad.devops.lanit-tercom.com/icons/IconCopy_size_s.svg",
                "order": 2
            },
            {
                "name": "Модели",
                "owner": owner,
                "icon": "https://web-module.dsgrad.devops.lanit-tercom.com/icons/IconCopy_size_s.svg",
                "order": 3
            },
            {
                "name": "Результаты",
                "owner": owner,
                "icon": "https://web-module.dsgrad.devops.lanit-tercom.com/icons/IconCopy_size_s.svg",
                "order": 4
            },
        ]
        if not return_objects:
            res = []
            for args in colls:
                res.append(Collection.objects.create(**args).pk)
            return res
        else:
            collections = []
            res = []
            for args in colls:
                collections.append(Collection.objects.create(**args))
            for collection in collections:
                res.append(collection.pk)
            return res, collections

    def create_default_model(self, new_collections):
        default_project = Project.objects.get(pk=4)
        for collection in default_project.collections.all():
            for ph_obj_type in collection.physical_object_types.all():
                collection_name = ph_obj_type.collection.name
                research_types = [res_type for res_type in ph_obj_type.research_types.all()]
                for new_collection in new_collections:
                    if new_collection.name == collection_name:
                        ph_obj_type.collection = new_collection
                ph_obj_type.pk = None
                ph_obj_type.save()
                for research_type in research_types:
                    research_type.pk = None
                    research_type.physical_object_type = ph_obj_type
                    research_type.save()

    def create_initial_log(self, project):
        log = ProjectLog.objects.create(name=f"Журнал проекта '{project.name}'", project=project)
        current_user = self.request.user
        ProjectLogRecord.objects.create(type="info", log=log, text=f"Создан проект '{project.name}'",
                                        user=f"Пользователь '{current_user}'")

    def create(self, request, *args, **kwargs):
        data = request.data
        data['collections'], collection_objects = self.create_default_collections(owner=request.user,
                                                                                  return_objects=True)
        serializer = self.serializer_class(data=data)
        if serializer.is_valid():
            proj = serializer.save()
            self.create_initial_log(proj)
            self.create_default_model(collection_objects)
            return Response(serializer.data, status=rest_framework.status.HTTP_201_CREATED)
        return Response(serializer.errors, status=rest_framework.status.HTTP_400_BAD_REQUEST)

    @action(detail=True, methods=["get"], url_path='collections')
    def get_collections(self, request, pk=None):
        project = self.get_object()
        collections = project.collections.all()
        serializer = CollectionSerializer(collections, many=True)
        return Response(serializer.data)

    @action(detail=True, methods=["post"], url_path='copy_project')
    def copy_project(self, request, pk=None):

        project = get_object_or_404(Project, pk=pk)
        fmodules = project.modules.all()
        deposits = project.deposit.all()
        # id коллекций копируемого проекта в виде списка
        old_collection_ids = list(project.collections.all().values_list('id', flat=True))

        # If the object’s primary key attribute is not set, Django executes an INSERT.
        project.pk = None
        project.save(is_copied=True)
        collections_pk, collection_objects = self.create_default_collections(owner=request.user,
                                                                             return_objects=True)
        project.collections.set(collections_pk)
        project.modules.set(fmodules)
        project.deposit.set(deposits)
        for i in old_collection_ids:
            obj_type_ids = Collection.objects.get(id=i).physical_object_types.all().values_list('id', flat=True)
            old_and_new_obj_id_dict = {}
            for obj_type_id in obj_type_ids:
                ph_obj_type = PhysicalObjectType.objects.get(id=obj_type_id)
                research_type_ids = ph_obj_type.research_types.all().values_list('id', flat=True)
                ph_obj_ids = ph_obj_type.physical_objects.all().values_list('id', flat=True)
                ph_obj_type.id = None
                ph_obj_type.collection = Collection.objects.get(pk=collections_pk[old_collection_ids.index(i)])
                ph_obj_type.save()
                for old_ph_obj_id in ph_obj_ids:
                    obj = PhysicalObject.objects.get(id=old_ph_obj_id)
                    obj.id = None
                    obj.entity_type = ph_obj_type
                    obj.save()
                    old_and_new_obj_id_dict.update({old_ph_obj_id: obj.id})
                for old_research_type_id in research_type_ids:
                    research_type = ResearchType.objects.get(pk=old_research_type_id)
                    research_ids = research_type.researches_type.all().values_list('id', flat=True)
                    research_type.id = None
                    research_type.physical_object_type = ph_obj_type
                    research_type.save()
                    for old_research_id in research_ids:
                        research = Research.objects.get(id=old_research_id)
                        old_ph_obj_id = research.physical_object.id
                        research.id = None
                        research.entity_type = research_type
                        research.physical_object = PhysicalObject.objects.get(id=old_and_new_obj_id_dict[old_ph_obj_id])
                        research.save()

        self.create_initial_log(project)
        # self.create_default_model(collection_objects)
        serializer = ProjectSerializer(project)
        return Response(serializer.data, status=rest_framework.status.HTTP_201_CREATED)

    @action(detail=True, methods=["get"], url_path='log')
    def get_project_log(self, request, pk=None):
        project_log = get_object_or_404(ProjectLog, project=self.get_object())
        records = project_log.records.all()
        serializer = ProjectLogRecordSerializer(records, many=True)
        return Response(serializer.data)

    @action(detail=True, methods=['get'], url_name='export', url_path='export')
    def export(self, request, system_id=None):
        export_systems = {
           1: 'Контур Бурение',
           2: 'Искра',
           3: 'Терра',
        }

        if export_systems[system_id] == 'Контур Бурение':
            try:
                serializer = ...
                return Response(serializer.data)

            except Exception:
                return Response(status=status.HTTP_400_BAD_REQUEST)

        return Response(status=status.HTTP_200_OK)


class StyleTemplateViewSet(viewsets.ModelViewSet):
    queryset = StyleTemplate.objects.all()
    serializer_class = StyleTemplateSerializer
    permission_classes = (IsAuthenticated,)