Skip to content
The Chat Archive
o1-preview-2024-09-12· OpenAI WildChat-4.8M (AI2)

from django.db import models from djangominiobackend import MinioBackend class…

  1. User

    from django.db import models from django_minio_backend import MinioBackend

    class BaseFile(models.Model): id = models.BigAutoField(primary_key=True, db_column="id_object") file_name = models.CharField(max_length=100)

    class Meta:
        abstract = True
    

    class VideoFile(BaseFile): duration = models.PositiveIntegerField("Длительность в мс", null=True) frame_rate = models.IntegerField("Частота кадров", null=True) file_path = models.FileField(storage=MinioBackend(bucket_name="archive-kffd"), upload_to="video") material = models.ForeignKey( "VideoMaterial", verbose_name="Видео-файл", related_name="media_files", on_delete=models.PROTECT, db_column="id_main", )

    class Meta:
        db_table = "archive_video_file"
        ordering = ("id",)
    

    class AudioFile(BaseFile): duration = models.PositiveIntegerField("Длительность в мс", null=True) file_path = models.FileField(storage=MinioBackend(bucket_name="archive-kffd"), upload_to="audio") material = models.ForeignKey( "AudioMaterial", verbose_name="Аудио-файл", related_name="media_files", on_delete=models.PROTECT, db_column="id_main", )

    class Meta:
        db_table = "archive_audio_file"
        ordering = ("id",)
    

    class ImageFile(BaseFile): file_path = models.FileField(storage=MinioBackend(bucket_name="archive-kffd"), upload_to="image") material = models.ForeignKey( "ImageMaterial", verbose_name="Фото-файл", related_name="media_files", on_delete=models.PROTECT, db_column="id_main", )

    class Meta:
        db_table = "archive_image_file"
        ordering = ("id",)
    

    class CreationDateVariant(models.IntegerChoices): ONLY_YEAR = 1, "только год" MONTH_AND_YEAR = 3, "год и месяц" FULL_DATE = 7, "год, месяц и число"

    class BaseMaterial(models.Model): id = models.BigAutoField(primary_key=True, db_column="id_main") keywords = models.CharField("Ключевые слова", max_length=512, blank=True) annotation = models.TextField("Аннотация", blank=True) archive_number = models.CharField(max_length=256, unique=True) persons = models.CharField("Персоналии", max_length=1024, blank=True) source = models.CharField("Источник поступления", max_length=256, blank=True) founder = models.CharField("Фондообразователь", max_length=256, blank=True) creation_date = models.DateField("Дата создания", null=True) creation_date_key = models.SmallIntegerField( help_text="Показывает какая часть даты известна в двоичном формате: " "001 (1) только год, " "011 (3) год и месяц, " "111 (7) год месяц и число", choices=CreationDateVariant.choices, null=True, ) creation_date_comment = models.CharField("Дата создания комментарий", max_length=1024, blank=True) creation_place = models.CharField("Место создания", max_length=256, blank=True) receive_date = models.DateField("Дата поступления", null=True)

    class Meta:
        abstract = True
    

    class AudioMaterial(BaseMaterial): title = models.CharField("Название", max_length=512, blank=True) text_author = models.CharField("Автор текста", max_length=256, blank=True) performer = models.CharField("Исполнитель", max_length=256, blank=True) music_author = models.CharField("Автор музыки", max_length=256, blank=True) arrangement = models.CharField("Аранжировка", max_length=256, blank=True) conductor = models.CharField("Дирижер", max_length=256, blank=True) art_director = models.CharField("Художественный руководитель", max_length=256, blank=True) language = models.CharField("Язык", max_length=256, blank=True) choir = models.CharField("Сопровождение (хор)", max_length=256, blank=True) orchestra = models.CharField("Сопровождение (инструменты)", max_length=256, blank=True) montage_sheet = models.TextField("Монтажный лист", blank=True)

    class Meta:
        verbose_name = "Фонодокумент"
        verbose_name_plural = "Фонодокументы"
        db_table = "archive_audio_material"
        ordering = ("id",)
    

    class VideoMaterial(BaseMaterial): title = models.CharField("Название", max_length=512, blank=True) description = models.TextField("Описание сюжета", blank=True) montage_sheet = models.TextField("Монтажный лист", blank=True) roles = models.TextField("В ролях", blank=True) scriptwriter = models.CharField("Сценарист", max_length=512, blank=True) director = models.CharField("Режиссер", max_length=512, blank=True) cameraman = models.CharField("Оператор", max_length=512, blank=True) sound_engineer = models.CharField("Звукооператор", max_length=512, blank=True) painter = models.CharField("Художник", max_length=512, blank=True) composer = models.CharField("Композитор", max_length=512, blank=True) studio = models.CharField("Студия", max_length=512, blank=True) role_dubbing = models.CharField("Роли озвучивали", max_length=1024, blank=True) video_creators = models.CharField("Над фильмом работали", max_length=1024, blank=True) video_type = models.CharField("Вид документа", max_length=256, blank=True) color = models.CharField("Цветность", max_length=256, blank=True) language = models.CharField("Язык", max_length=256, blank=True) literature_source = models.CharField("Литературный первоисточник", max_length=512, blank=True) voice_type = models.CharField("Озвученность", max_length=256, blank=True)

    class Meta:
        verbose_name = "Киновидеодокумент"
        verbose_name_plural = "Киновидеодокументы"
        db_table = "archive_video_material"
        ordering = ("id",)
    

    class ImageMaterial(BaseMaterial): author = models.CharField("Автор", max_length=256, blank=True) photo_type = models.CharField("Вид фотодокумента", max_length=256, blank=True) color = models.CharField("Цветность", max_length=256, blank=True)

    class Meta:
        verbose_name = "Фотодокумент"
        verbose_name_plural = "Фотодокументы"
        db_table = "archive_image_material"
        ordering = ("id",)
    

    from django.db.models import Q from rest_framework import viewsets from rest_framework.response import Response from rest_framework import status from backend.apps.archive.models import AudioMaterial, ImageMaterial, VideoMaterial from . import serializers from django.utils.text import capfirst from rest_framework.metadata import SimpleMetadata import logging

    Set up logging

    logger = logging.getLogger(name)

    class SerializerFieldsMetadata(SimpleMetadata): """ This class is responsible for generating metadata for fields, including 'beautiful' names and handling widget and choice field details. """

    def get_field_info(self, field):
        field_info = super().get_field_info(field)
        field_info["label"] = capfirst(field.label or field.field_name)
        field_info["type"] = field.__class__.__name__
    
        if isinstance(field, serializers.ChoiceField):
            field_info["choices"] = [{"value": key, "display_name": value} for key, value in field.choices.items()]
    
        return field_info
    
    def determine_metadata(self, request, view):
        metadata = super().determine_metadata(request, view)
        metadata["verbose_name"] = view.get_queryset().model._meta.verbose_name
        metadata["verbose_name_plural"] = view.get_queryset().model._meta.verbose_name_plural
        return metadata
    

    class BaseMaterialViewSet(viewsets.ReadOnlyModelViewSet): """Base ViewSet for all media materials.""" metadata_class = SerializerFieldsMetadata

    def get_queryset(self):
        queryset = super().get_queryset()
        search_query = self.request.query_params.get("common_search_query")
        logger.debug(f"Search query: {search_query}")
    
        logger.debug(f"Initial queryset count: {queryset.count()}")
    
        if search_query:
            query_lookup = Q()
            for field in self.common_search_fields:
                query_lookup |= Q(**{f"{field}__icontains": search_query})
            queryset = queryset.filter(query_lookup)
    
            logger.debug(f"Filtered queryset count: {queryset.count()}")
            logger.debug(f"SQL query: {queryset.query}")
    
        return queryset
    
    def list(self, request, *args, **kwargs):
        queryset = self.get_queryset()
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
    
        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)
    
    def options(self, request, *args, **kwargs):
        """Customized method for providing field metadata."""
        metadata = self.metadata_class().determine_metadata(request, self)
        return Response(metadata, status=status.HTTP_200_OK)
    

    class AudioMaterialViewSet(BaseMaterialViewSet): queryset = AudioMaterial.objects.all() serializer_class = serializers.AudioMaterialListSerializer common_search_fields = ["keywords", "annotation", "persons", "title"]

    class ImageMaterialViewSet(BaseMaterialViewSet): queryset = ImageMaterial.objects.all() serializer_class = serializers.ImageMaterialListSerializer common_search_fields = ["keywords", "annotation", "persons", "author"]

    class VideoMaterialViewSet(BaseMaterialViewSet): queryset = VideoMaterial.objects.all() serializer_class = serializers.VideoMaterialListSerializer common_search_fields = ["keywords", "annotation", "persons", "title", "description"] import re

    from rest_framework import serializers

    from . import models

    class ImageMaterialListSerializer(serializers.ModelSerializer): creation_date = serializers.SerializerMethodField() annotation = serializers.SerializerMethodField()

    @staticmethod
    def get_annotation(instance):
        max_tokens = 11
        if instance.annotation:
            tokens = re.findall(r"\S+", instance.annotation)
            annotation = " ".join(tokens[:max_tokens])
            annotation += " ..." if len(tokens) > max_tokens else ""
            return annotation
    
    @staticmethod
    def get_creation_date(instance):
        match instance.creation_date_key:
            case models.CreationDateVariant.ONLY_YEAR:
                return instance.creation_date.year
            case models.CreationDateVariant.MONTH_AND_YEAR:
                return instance.creation_date.strftime("%m.%Y")
            case models.CreationDateVariant.FULL_DATE:
                return instance.creation_date.strftime("%d.%m.%Y")
    
    class Meta:
        model = models.ImageMaterial
        fields = ("id", "archive_number", "annotation", "creation_date", "author", "photo_type", "color")
    

    class AudioMaterialListSerializer(ImageMaterialListSerializer): class Meta: model = models.AudioMaterial fields = ("id", "archive_number", "title", "annotation", "performer", "creation_date", "language")

    class VideoMaterialListSerializer(ImageMaterialListSerializer): class Meta: model = models.VideoMaterial fields = ("id", "archive_number", "title", "creation_date", "annotation", "roles", "language") from rest_framework.routers import DefaultRouter

    from . import views

    router = DefaultRouter() router.register(r"audio-materials", views.AudioMaterialViewSet, basename="audio-materials") router.register(r"image-materials", views.ImageMaterialViewSet, basename="image-materials") router.register(r"video-materials", views.VideoMaterialViewSet, basename="video-materials")

    urlpatterns = [*router.urls] {{ getFieldLabel(key) }}: {{ value }}

  2. Assistant

    The issue you're experiencing stems from the fact that SerializerMethodField in your serializers doesn't automatically pick up the verbose_name from your model fields. Consequently, the labels for these fields default to the field names in English, rather than the Russian verbose_name you've specified in your models.py.

    To fix this, you need to explicitly set the label attribute for each SerializerMethodField in your serializers to match the verbose_name you've set in your models. Here's how you can do it:

    Update your serializers.py file: Add the label parameter to each SerializerMethodField to ensure it uses the correct Russian label.

    import re
    from rest_framework import serializers
    from . import models
    
    
    class ImageMaterialListSerializer(serializers.ModelSerializer):
        # Set the label to the verbose_name from the model
        creation_date = serializers.SerializerMethodField(label='Дата создания')
        annotation = serializers.SerializerMethodField(label='Аннотация')
    
        @staticmethod
        def get_annotation(instance):
            max_tokens = 11
            if instance.annotation:
                tokens = re.findall(r"\S+", instance.annotation)
                annotation = " ".join(tokens[:max_tokens])
                annotation += " ..." if len(tokens) > max_tokens else ""
                return annotation
    
        @staticmethod
        def get_creation_date(instance):
            match instance.creation_date_key:
                case models.CreationDateVariant.ONLY_YEAR:
                    return instance.creation_date.year
                case models.CreationDateVariant.MONTH_AND_YEAR:
                    return instance.creation_date.strftime("%m.%Y")
                case models.CreationDateVariant.FULL_DATE:
                    return instance.creation_date.strftime("%d.%m.%Y")
    
        class Meta:
            model = models.ImageMaterial
            fields = ("id", "archive_number", "annotation", "creation_date", "author", "photo_type", "color")
    
    
    class AudioMaterialListSerializer(ImageMaterialListSerializer):
        class Meta:
            model = models.AudioMaterial
            fields = ("id", "archive_number", "title", "annotation", "performer", "creation_date", "language")
    
    
    class VideoMaterialListSerializer(ImageMaterialListSerializer):
        class Meta:
            model = models.VideoMaterial
            fields = ("id", "archive_number", "title", "creation_date", "annotation", "roles", "language")
    

    Explanation:

    • By setting the label parameter in SerializerMethodField, you ensure that when your serializer's metadata is generated, it includes the correct Russian labels.

    Update your views.py if necessary:

    If you want to ensure that all fields, including those in other serializers or any future SerializerMethodField, automatically pick up the verbose_name from the model, you can modify the get_field_info method in your SerializerFieldsMetadata class to try to get the label from the model field's verbose_name when the label is not explicitly set.

    def get_field_info(self, field):
        field_info = super().get_field_info(field)
        field_info["type"] = field.__class__.__name__
    
        if field.label:
            field_info["label"] = capfirst(field.label)
        else:
            # Try to get label from model field
            model = getattr(field.parent.Meta, 'model', None)
            source = field.source or field.field_name
            if model and source != '*':
                try:
                    model_field = model._meta.get_field(source)
                    field_info['label'] = capfirst(model_field.verbose_name)
                except FieldDoesNotExist:
                    field_info['label'] = capfirst(field.field_name)
            else:
                field_info['label'] = capfirst(field.field_name)
        
        if isinstance(field, serializers.ChoiceField):
            field_info["choices"] = [{"value": key, "display_name": value} for key, value in field.choices.items()]
        return field_info
    

    Full Corrected Code:

    Below is the full corrected code for your models.py, serializers.py, views.py, and the Vue.js template, incorporating the fix:


    models.py

    # No changes needed; assuming your verbose_names are already set in Russian.
    

    serializers.py

    import re
    from rest_framework import serializers
    from . import models
    
    
    class ImageMaterialListSerializer(serializers.ModelSerializer):
        creation_date = serializers.SerializerMethodField(label='Дата создания')
        annotation = serializers.SerializerMethodField(label='Аннотация')
    
        @staticmethod
        def get_annotation(instance):
            max_tokens = 11
            if instance.annotation:
                tokens = re.findall(r"\S+", instance.annotation)
                annotation = " ".join(tokens[:max_tokens])
                annotation += " ..." if len(tokens) > max_tokens else ""
                return annotation
    
        @staticmethod
        def get_creation_date(instance):
            match instance.creation_date_key:
                case models.CreationDateVariant.ONLY_YEAR:
                    return instance.creation_date.year
                case models.CreationDateVariant.MONTH_AND_YEAR:
                    return instance.creation_date.strftime("%m.%Y")
                case models.CreationDateVariant.FULL_DATE:
                    return instance.creation_date.strftime("%d.%m.%Y")
    
        class Meta:
            model = models.ImageMaterial
            fields = ("id", "archive_number", "annotation", "creation_date", "author", "photo_type", "color")
    
    
    class AudioMaterialListSerializer(ImageMaterialListSerializer):
        class Meta:
            model = models.AudioMaterial
            fields = ("id", "archive_number", "title", "annotation", "performer", "creation_date", "language")
    
    
    class VideoMaterialListSerializer(ImageMaterialListSerializer):
        class Meta:
            model = models.VideoMaterial
            fields = ("id", "archive_number", "title", "creation_date", "annotation", "roles", "language")
    

    views.py

    from django.db.models import Q
    from rest_framework import viewsets
    from rest_framework.response import Response
    from rest_framework import status
    from backend.apps.archive.models import AudioMaterial, ImageMaterial, VideoMaterial
    from . import serializers
    from django.utils.text import capfirst
    from rest_framework.metadata import SimpleMetadata
    from django.core.exceptions import FieldDoesNotExist
    import logging
    
    # Set up logging
    logger = logging.getLogger(__name__)
    
    class SerializerFieldsMetadata(SimpleMetadata):
        """
        This class is responsible for generating metadata for fields, including 'beautiful' names
        and handling widget and choice field details.
        """
    
        def get_field_info(self, field):
            field_info = super().get_field_info(field)
            field_info["type"] = field.__class__.__name__
    
            if field.label:
                field_info["label"] = capfirst(field.label)
            else:
                # Try to get label from model field
                model = getattr(field.parent.Meta, 'model', None)
                source = field.source or field.field_name
                if model and source != '*':
                    try:
                        model_field = model._meta.get_field(source)
                        field_info['label'] = capfirst(model_field.verbose_name)
                    except FieldDoesNotExist:
                        field_info['label'] = capfirst(field.field_name)
                else:
                    field_info['label'] = capfirst(field.field_name)
            
            if isinstance(field, serializers.ChoiceField):
                field_info["choices"] = [{"value": key, "display_name": value} for key, value in field.choices.items()]
            return field_info
    
        def determine_metadata(self, request, view):
            metadata = super().determine_metadata(request, view)
            metadata["verbose_name"] = view.get_queryset().model._meta.verbose_name
            metadata["verbose_name_plural"] = view.get_queryset().model._meta.verbose_name_plural
            return metadata
    
    class BaseMaterialViewSet(viewsets.ReadOnlyModelViewSet):
        """Base ViewSet for all media materials."""
        metadata_class = SerializerFieldsMetadata
    
        def get_queryset(self):
            queryset = super().get_queryset()
            search_query = self.request.query_params.get("common_search_query")
            logger.debug(f"Search query: {search_query}")
    
            logger.debug(f"Initial queryset count: {queryset.count()}")
    
            if search_query:
                query_lookup = Q()
                for field in self.common_search_fields:
                    query_lookup |= Q(**{f"{field}__icontains": search_query})
                queryset = queryset.filter(query_lookup)
    
                logger.debug(f"Filtered queryset count: {queryset.count()}")
                logger.debug(f"SQL query: {queryset.query}")
    
            return queryset
    
        def list(self, request, *args, **kwargs):
            queryset = self.get_queryset()
            page = self.paginate_queryset(queryset)
            if page is not None:
                serializer = self.get_serializer(page, many=True)
                return self.get_paginated_response(serializer.data)
    
            serializer = self.get_serializer(queryset, many=True)
            return Response(serializer.data, status=status.HTTP_200_OK)
    
        def options(self, request, *args, **kwargs):
            """Customized method for providing field metadata."""
            metadata = self.metadata_class().determine_metadata(request, self)
            return Response(metadata, status=status.HTTP_200_OK)
    
    class AudioMaterialViewSet(BaseMaterialViewSet):
        queryset = AudioMaterial.objects.all()
        serializer_class = serializers.AudioMaterialListSerializer
        common_search_fields = ["keywords", "annotation", "persons", "title"]
    
    class ImageMaterialViewSet(BaseMaterialViewSet):
        queryset = ImageMaterial.objects.all()
        serializer_class = serializers.ImageMaterialListSerializer
        common_search_fields = ["keywords", "annotation", "persons", "author"]
    
    class VideoMaterialViewSet(BaseMaterialViewSet):
        queryset = VideoMaterial.objects.all()
        serializer_class = serializers.VideoMaterialListSerializer
        common_search_fields = ["keywords", "annotation", "persons", "title", "description"]
    

    urls.py

    from rest_framework.routers import DefaultRouter
    
    from . import views
    
    router = DefaultRouter()
    router.register(r"audio-materials", views.AudioMaterialViewSet, basename="audio-materials")
    router.register(r"image-materials", views.ImageMaterialViewSet, basename="image-materials")
    router.register(r"video-materials", views.VideoMaterialViewSet, basename="video-materials")
    
    urlpatterns = [*router.urls]
    

    Vue.js Template

    <template>
      <v-data-iterator :items="items" class="d-flex justify-center">
        <template v-slot:default="{ items }">
          <template v-for="(item, index) in items" :key="index">
            <div class="item">
              <div class="item-icon">
                <v-icon :size="110" color="primary-violet" :icon="iconMap[materialType] || 'mdi-file-document-outline'"></v-icon>
              </div>
              <div class="item-content">
                <div v-for="(value, key) in item.raw" :key="key" class="item-field">
                  <span class="field-label">{{ getFieldLabel(key) }}:</span>
                  <span class="field-value">{{ value }}</span>
                </div>
              </div>
            </div>
          </template>
        </template>
      </v-data-iterator>
    </template>
    
    <script setup>
    import { ref, onMounted, watch } from 'vue';
    import axios from 'axios';
    
    const props = defineProps({
      items: Array,
      materialType: String
    });
    
    const fields = ref({});
    
    const iconMap = {
      audio: 'mdi-volume-high',
      photo: 'mdi-image-outline',
      video: 'mdi-video-outline'
    };
    
    const fetchFieldsMetadata = () => {
      axios.options(`/api/materials/${props.materialType}/`)
        .then(({ data }) => {
          fields.value = data.actions?.POST || {};
          console.log('Fetched metadata:', fields.value);
        })
        .catch(error => {
          console.error('Error fetching field metadata:', error);
        });
    };
    
    const getFieldLabel = (key) => {
      const label = fields.value[key]?.label || key;
      console.log(`Field: ${key}, Label: ${label}`);
      return label;
    };
    
    watch(() => props.materialType, fetchFieldsMetadata);
    
    onMounted(fetchFieldsMetadata);
    </script>
    
    <style scoped>
    .item {
      width: 900px;
      padding: 15px;
      margin-top: 15px;
      margin-bottom: 15px;
      border: 1px solid darkgray;
      border-radius: 8px;
      display: flex;
      overflow: hidden;
    }
    
    .item-icon {
      flex-shrink: 0;
      width: 110px;
    }
    
    .item-content {
      flex-grow: 1;
      margin-left: 20px;
      overflow: hidden;
    }
    
    .item-field {
      display: flex;
      margin-bottom: 8px;
    }
    
    .field-label {
      flex-shrink: 0;
      font-size: 12px;
      font-weight: bold;
      color: var(--color-primary);
      margin-right: 12px;
    }
    
    .field-value {
      font-size: 12px;
      font-weight: normal;
      white-space: nowrap;
      overflow: hidden;
      text-overflow: ellipsis;
    }
    </style>
    

    Note:

    • Ensure your API endpoints (/api/materials/${props.materialType}/) are correctly configured and accessible.
    • In the Vue.js component, we're fetching field metadata using an OPTIONS request and storing the field information, including labels.

    With these changes, the labels displayed in your Vue.js application should correctly reflect the Russian verbose_name set in your models.py, solving the problem of displaying field names in English.