django模型过滤视图

# your_app/models.py

from django.db import models

# 定义Author模型
class Author(models.Model):
    # 定义作者姓名字段，最大长度为100
    name = models.CharField(max_length=100)
    # 定义作者出生日期字段
    birth_date = models.DateField()

    # 定义字符串表示形式，返回作者姓名
    def __str__(self):
        return self.name

# 定义Book模型
class Book(models.Model):
    # 定义书名字段，最大长度为200
    title = models.CharField(max_length=200)
    # 定义外键字段，关联到Author模型，删除Author时删除关联的Book
    author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE)
    # 定义书籍出版日期字段
    published_date = models.DateField()

    # 定义字符串表示形式，返回书名
    def __str__(self):
        return self.title

# your_app/serializers.py

from rest_framework import serializers
from .models import Author, Book

# 定义Author模型的序列化器
class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        # 指定序列化器对应的模型是Author
        model = Author
        # 指定需要序列化的字段
        fields = ['id', 'name', 'birth_date']

# 定义Book模型的序列化器
class BookSerializer(serializers.ModelSerializer):
    # 嵌套Author序列化器，用于序列化Author字段
    author = AuthorSerializer()

    class Meta:
        # 指定序列化器对应的模型是Book
        model = Book
        # 指定需要序列化的字段
        fields = ['id', 'title', 'author', 'published_date']

# your_app/filters.py

import django_filters
from .models import Book

# 定义Book模型的过滤类
class BookFilter(django_filters.FilterSet):
    # 定义过滤器，按书名模糊查询
    title = django_filters.CharFilter(lookup_expr='icontains')
    # 定义过滤器，按作者姓名模糊查询
    author_name = django_filters.CharFilter(field_name='author__name', lookup_expr='icontains')
    # 定义过滤器，按出版日期精确查询
    published_date = django_filters.DateFilter()

    class Meta:
        # 指定过滤器对应的模型是Book
        model = Book
        # 指定可以被过滤的字段
        fields = ['title', 'author_name', 'published_date']

# your_app/views.py

from rest_framework import viewsets
from django_filters.rest_framework import DjangoFilterBackend
from .models import Book
from .serializers import BookSerializer
from .filters import BookFilter

# 定义Book模型的视图集
class BookViewSet(viewsets.ModelViewSet):
    # 指定视图集使用的查询集
    queryset = Book.objects.all()
    # 指定视图集使用的序列化器
    serializer_class = BookSerializer
    # 指定视图集使用的过滤后端
    filter_backends = [DjangoFilterBackend]
    # 指定视图集使用的过滤类
    filterset_class = BookFilter

# your_app/urls.py

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import BookViewSet

# 创建一个默认的路由对象
router = DefaultRouter()
# 注册Book视图集，路由前缀为'books'
router.register(r'books', BookViewSet, basename='book')

# 定义URL模式
urlpatterns = [
    # 包含路由对象生成的所有URL模式
    path('', include(router.urls)),
]

# your_project/urls.py

from django.contrib import admin
from django.urls import path, include

# 定义项目级别的URL模式
urlpatterns = [
    # 管理后台的URL模式
    path('admin/', admin.site.urls),
    # 包含应用的URL模式，前缀为'api/'
    path('api/', include('your_app.urls')),
]

# your_app/models.py

from django.db import models

# 定义 Book 模型
class Book(models.Model):
    # 定义书名字段，最大长度为200
    title = models.CharField(max_length=200)
    # 定义作者字段，最大长度为100
    author = models.CharField(max_length=100)
    # 定义出版日期字段
    published_date = models.DateField()

    # 定义字符串表示形式，返回书名
    def __str__(self):
        return self.title

# your_app/filters.py

import django_filters
from django_filters import rest_framework as filters
from .models import Book

# 定义一个用于处理字符类型列表的自定义过滤器
class CharInFilter(filters.BaseInFilter, filters.CharFilter):
    pass

# 定义 Book 模型的过滤器类
class BookFilter(filters.FilterSet):
    # 使用自定义过滤器来处理书名的列表过滤
    title = CharInFilter(field_name='title', lookup_expr='in')
    # 使用自定义过滤器来处理作者的列表过滤
    author = CharInFilter(field_name='author', lookup_expr='in')
    # 使用标准日期过滤器来处理出版日期的精确过滤
    published_date = filters.DateFilter()

    class Meta:
        # 指定过滤器对应的模型是 Book
        model = Book
        # 指定可以被过滤的字段
        fields = ['title', 'author', 'published_date']

# your_app/views.py

import pandas as pd
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django_filters.rest_framework import DjangoFilterBackend
from .models import Book
from .filters import BookFilter

# 定义一个处理 XLSX 文件上传的视图
class UploadXLSXView(APIView):
    # 指定使用 DjangoFilterBackend 作为过滤后端
    filter_backends = [DjangoFilterBackend]
    # 指定使用的过滤器类
    filterset_class = BookFilter

    # 处理 POST 请求的方法
    def post(self, request, *args, **kwargs):
        # 从请求中获取上传的文件
        file = request.FILES.get('file')
        if not file:
            # 如果没有提供文件，返回400错误响应
            return Response({"error": "No file provided"}, status=status.HTTP_400_BAD_REQUEST)

        # 使用 Pandas 读取 XLSX 文件
        df = pd.read_excel(file)

        # 期望的列名
        expected_columns = ['title', 'author', 'published_date']
        # 检查文件中是否包含所有期望的列
        if not all(column in df.columns for column in expected_columns):
            # 如果缺少任何期望的列，返回400错误响应
            return Response({"error": "Invalid file format"}, status=status.HTTP_400_BAD_REQUEST)

        # 获取所有标题、作者和出版日期，转换为列表
        titles = df['title'].tolist()
        authors = df['author'].tolist()
        published_dates = df['published_date'].tolist()

        # 创建过滤器集实例，用于过滤数据库中的数据
        filterset = BookFilter(data={
            'title': titles,
            'author': authors,
            'published_date': published_dates
        }, queryset=Book.objects.all())

        results = []
        if filterset.is_valid():
            # 如果过滤器集有效，逐行检查数据是否存在于数据库中
            for title, author, published_date in zip(titles, authors, published_dates):
                # 使用过滤器集查询数据库
                exists = filterset.qs.filter(title=title, author=author, published_date=published_date).exists()
                # 将结果添加到结果列表中
                results.append({
                    "title": title,
                    "author": author,
                    "published_date": published_date,
                    "exists": exists
                })
        else:
            # 如果过滤器集无效，返回400错误响应
            return Response(filterset.errors, status=status.HTTP_400_BAD_REQUEST)

        # 返回结果列表作为响应
        return Response(results, status=status.HTTP_200_OK)

# your_app/urls.py

from django.urls import path
from .views import UploadXLSXView

# 定义应用的URL模式
urlpatterns = [
    # 配置处理 XLSX 文件上传的视图
    path('upload/', UploadXLSXView.as_view(), name='upload-xlsx'),
]

# your_project/urls.py

from django.contrib import admin
from django.urls import path, include

# 定义项目级别的URL模式
urlpatterns = [
    # 管理后台的URL模式
    path('admin/', admin.site.urls),
    # 包含应用的URL模式，前缀为'api/'
    path('api/', include('your_app.urls')),
]

# your_app/models.py

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()

    def __str__(self):
        return self.title

class BookColumn(models.Model):
    FIELD_TYPE_CHOICES = (
        ('char', 'CharField'),
        ('date', 'DateField'),
    )

    name = models.CharField(max_length=100)  # 字段名
    field_type = models.CharField(max_length=10, choices=FIELD_TYPE_CHOICES)  # 字段类型
    regex = models.CharField(max_length=200, blank=True, null=True)  # 正则表达式校验
    required = models.BooleanField(default=True)  # 是否必填

    def __str__(self):
        return self.name

# your_app/filters.py

import django_filters
from django_filters import rest_framework as filters
from .models import Book

class CharInFilter(filters.BaseInFilter, filters.CharFilter):
    pass

class BookFilter(filters.FilterSet):
    title = CharInFilter(field_name='title', lookup_expr='in')
    author = CharInFilter(field_name='author', lookup_expr='in')
    published_date = filters.DateFilter()

    class Meta:
        model = Book
        fields = ['title', 'author', 'published_date']

# your_app/views.py

import pandas as pd
import re
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import Book, BookColumn

class UploadXLSXView(APIView):

    def post(self, request, *args, **kwargs):
        file = request.FILES.get('file')
        if not file:
            return Response({"error": "No file provided"}, status=status.HTTP_400_BAD_REQUEST)

        # 读取 XLSX 文件
        df = pd.read_excel(file)

        # 获取所有的校验规则
        validation_rules = BookColumn.objects.all()
        errors = []

        for index, row in df.iterrows():
            row_errors = {}
            for rule in validation_rules:
                field_name = rule.name
                field_value = row.get(field_name)

                # 校验必填项
                if rule.required and (field_value is None or pd.isna(field_value)):
                    row_errors[field_name] = 'This field is required.'
                    continue

                # 正则表达式校验
                if rule.regex and field_value:
                    if not re.match(rule.regex, str(field_value)):
                        row_errors[field_name] = 'Invalid format.'

            if row_errors:
                errors.append({"row": index + 1, "errors": row_errors})

        if errors:
            return Response({"errors": errors}, status=status.HTTP_400_BAD_REQUEST)

        # 如果没有错误，处理并保存数据
        results = []
        for index, row in df.iterrows():
            book_data = {
                'title': row['title'],
                'author': row['author'],
                'published_date': row['published_date']
            }
            # 在数据库中创建或更新 Book 实例
            book, created = Book.objects.update_or_create(
                title=book_data['title'],
                defaults=book_data
            )
            results.append(book_data)

        return Response(results, status=status.HTTP_200_OK)

# your_app/urls.py

from django.urls import path
from .views import UploadXLSXView

urlpatterns = [
    path('upload/', UploadXLSXView.as_view(), name='upload-xlsx'),
]

# your_project/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('your_app.urls')),
]

from django.db import models

# 定义 Book 模型
class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()

    def __str__(self):
        return self.title

# 定义 BookColumn 模型
class BookColumn(models.Model):
    field_name = models.CharField(max_length=100)  # Book 模型中的字段名
    validation_type = models.CharField(max_length=50)  # 校验类型（如 regex, max_length, min_value）
    validation_value = models.CharField(max_length=200)  # 校验值（如正则表达式）

    def __str__(self):
        return f'{self.field_name} - {self.validation_type}'

import re
from django.core.exceptions import ValidationError
from .models import BookColumn

def validate_data(data):
    errors = []
    columns = BookColumn.objects.all()
    
    for column in columns:
        field_name = column.field_name
        validation_type = column.validation_type
        validation_value = column.validation_value

        value = data.get(field_name)
        
        if validation_type == 'regex':
            if not re.match(validation_value, str(value)):
                errors.append(f'{field_name} does not match the required pattern.')
        
        elif validation_type == 'max_length':
            if len(str(value)) > int(validation_value):
                errors.append(f'{field_name} exceeds maximum length of {validation_value}.')
        
        elif validation_type == 'min_length':
            if len(str(value)) < int(validation_value):
                errors.append(f'{field_name} is less than minimum length of {validation_value}.')
        
        elif validation_type == 'max_value':
            if float(value) > float(validation_value):
                errors.append(f'{field_name} exceeds maximum value of {validation_value}.')
        
        elif validation_type == 'min_value':
            if float(value) < float(validation_value):
                errors.append(f'{field_name} is less than minimum value of {validation_value}.')

    return errors

import pandas as pd
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django_filters.rest_framework import DjangoFilterBackend
from .models import Book
from .filters import BookFilter
from .validators import validate_data

class UploadXLSXView(APIView):
    filter_backends = [DjangoFilterBackend]
    filterset_class = BookFilter

    def post(self, request, *args, **kwargs):
        file = request.FILES.get('file')
        if not file:
            return Response({"error": "No file provided"}, status=status.HTTP_400_BAD_REQUEST)

        df = pd.read_excel(file)
        expected_columns = ['title', 'author', 'published_date']
        if not all(column in df.columns for column in expected_columns):
            return Response({"error": "Invalid file format"}, status=status.HTTP_400_BAD_REQUEST)

        titles = df['title'].tolist()
        authors = df['author'].tolist()
        published_dates = df['published_date'].tolist()

        results = []
        for index, row in df.iterrows():
            row_data = row.to_dict()
            errors = validate_data(row_data)
            if errors:
                results.append({
                    "row": index + 1,
                    "errors": errors
                })
                continue
            
            filterset = BookFilter(data=row_data, queryset=Book.objects.all())
            if filterset.is_valid():
                exists = filterset.qs.filter(title=row_data['title'], author=row_data['author'], published_date=row_data['published_date']).exists()
                results.append({
                    "title": row_data['title'],
                    "author": row_data['author'],
                    "published_date": row_data['published_date'],
                    "exists": exists
                })
            else:
                results.append({
                    "row": index + 1,
                    "errors": filterset.errors
                })

        return Response(results, status=status.HTTP_200_OK)

from django.urls import path
from .views import UploadXLSXView

urlpatterns = [
    path('upload/', UploadXLSXView.as_view(), name='upload-xlsx'),
]

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('your_app.urls')),
]

# your_app/models.py

from django.db import models
from django.contrib.postgres.fields import JSONField  # 使用 PostgreSQL 的 JSONField

class YourModel(models.Model):
    file_name = models.CharField(max_length=255)
    file_metadata = JSONField(blank=True, null=True)  # JSON 字段

    def __str__(self):
        return self.file_name

# your_app/serializers.py

import re
from rest_framework import serializers
from .models import YourModel

class YourModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = YourModel
        fields = ['id', 'file_name', 'file_metadata']

    def validate_file_name(self, value):
        pattern = r'\[(.*?)\]-(.*)\.s4p'
        match = re.match(pattern, value)
        if not match:
            raise serializers.ValidationError("Invalid file name format.")
        
        details = match.group(1).split('_')
        type_ = details[0]
        metadata = {"type": type_}

        if type_ == 'thru':
            metadata["channel"] = details[1]
        elif type_ == 'fext':
            metadata["victim_pair"] = details[1]
            metadata["attacker_pair"] = details[3]
        else:
            metadata["details"] = details[1:]

        # 将解析后的数据存储到 file_metadata 中
        self.context['file_metadata'] = metadata

        return value

    def create(self, validated_data):
        file_metadata = self.context.get('file_metadata')
        instance = YourModel.objects.create(
            file_name=validated_data['file_name'],
            file_metadata=file_metadata
        )
        return instance

    def update(self, instance, validated_data):
        instance.file_name = validated_data.get('file_name', instance.file_name)
        instance.file_metadata = self.context.get('file_metadata', instance.file_metadata)
        instance.save()
        return instance

# your_app/views.py

from rest_framework import viewsets
from .models import YourModel
from .serializers import YourModelSerializer

class YourModelViewSet(viewsets.ModelViewSet):
    queryset = YourModel.objects.all()
    serializer_class = YourModelSerializer

# your_app/urls.py

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import YourModelViewSet

router = DefaultRouter()
router.register(r'yourmodel', YourModelViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

# your_app/models.py

from django.db import models
from django.contrib.postgres.fields import JSONField  # 使用 PostgreSQL 的 JSONField

class YourModel(models.Model):
    file_name = models.CharField(max_length=255)
    file_metadata = JSONField(blank=True, null=True)  # JSON 字段

    def __str__(self):
        return self.file_name

# your_app/validators.py

import re
from rest_framework import serializers

class DynamicFieldValidator:
    def __init__(self, field_name, validation_rules):
        self.field_name = field_name
        self.validation_rules = validation_rules

    def __call__(self, value):
        for rule in self.validation_rules:
            if rule['type'] == 'regex':
                if not re.match(rule['pattern'], value):
                    raise serializers.ValidationError(f"{self.field_name} does not match pattern {rule['pattern']}")
            # 可以添加更多规则类型
            # elif rule['type'] == 'min_length':
            #     if len(value) < rule['value']:
            #         raise serializers.ValidationError(f"{self.field_name} length is less than {rule['value']}")

# your_app/serializers.py

import re
from rest_framework import serializers
from .models import YourModel
from .validators import DynamicFieldValidator

class YourModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = YourModel
        fields = ['id', 'file_name', 'file_metadata']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.dynamic_validators = {
            'file_name': [DynamicFieldValidator('file_name', [{'type': 'regex', 'pattern': r'\[.*?\]-.*\.s4p'}])]
        }
        # 可以根据需要添加更多字段和其校验规则

    def validate(self, data):
        # 逐字段应用动态校验
        for field, validators in self.dynamic_validators.items():
            value = data.get(field)
            if value is not None:
                for validator in validators:
                    validator(value)

        # 自定义解析逻辑
        pattern = r'\[(.*?)\]-(.*)\.s4p'
        match = re.match(pattern, data['file_name'])
        if match:
            details = match.group(1).split('_')
            type_ = details[0]
            metadata = {"type": type_}
            if type_ == 'thru':
                metadata["channel"] = details[1]
            elif type_ == 'fext':
                metadata["victim_pair"] = details[1]
                metadata["attacker_pair"] = details[3]
            else:
                metadata["details"] = details[1:]
            data['file_metadata'] = metadata
        else:
            data['file_metadata'] = None
        
        return data

    def create(self, validated_data):
        instance = YourModel.objects.create(
            file_name=validated_data['file_name'],
            file_metadata=validated_data['file_metadata']
        )
        return instance

    def update(self, instance, validated_data):
        instance.file_name = validated_data.get('file_name', instance.file_name)
        instance.file_metadata = validated_data.get('file_metadata', instance.file_metadata)
        instance.save()
        return instance

# your_app/views.py

from rest_framework import viewsets
from .models import YourModel
from .serializers import YourModelSerializer

class YourModelViewSet(viewsets.ModelViewSet):
    queryset = YourModel.objects.all()
    serializer_class = YourModelSerializer

# your_app/urls.py

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import YourModelViewSet

router = DefaultRouter()
router.register(r'yourmodel', YourModelViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

# your_app/models.py

from django.db import models
from django.contrib.postgres.fields import JSONField

class YourModel(models.Model):
    file_name = models.CharField(max_length=255)  # 文件名字段
    file_metadata = JSONField(blank=True, null=True)  # JSON 字段，用于存储文件元数据

    def __str__(self):
        return self.file_name  # 返回文件名作为字符串表示

class ValidationRule(models.Model):
    field_name = models.CharField(max_length=255)  # 需要校验的字段名称
    rule_type = models.CharField(max_length=255)  # 校验规则类型，例如 'regex' 或 'min_length'
    rule_value = models.CharField(max_length=255)  # 校验规则的具体值，例如正则表达式或最小长度

    def __str__(self):
        return f"{self.field_name} - {self.rule_type}: {self.rule_value}"  # 返回校验规则的字符串表示

# your_app/validators.py

import re
from rest_framework import serializers

class DynamicFieldValidator:
    def __init__(self, field_name, rule_type, rule_value):
        self.field_name = field_name  # 字段名称
        self.rule_type = rule_type  # 校验规则类型
        self.rule_value = rule_value  # 校验规则的具体值

    def __call__(self, value):
        if self.rule_type == 'regex':
            if not re.match(self.rule_value, value):
                raise serializers.ValidationError(f"{self.field_name} does not match pattern {self.rule_value}")
        elif self.rule_type == 'min_length':
            if len(value) < int(self.rule_value):
                raise serializers.ValidationError(f"{self.field_name} length is less than {self.rule_value}")
        # 可以添加更多规则类型

# your_app/utils.py

import re

def parse_file_name(file_name):
    match = re.match(r'\[(.*?)\]-(.*?)\.s4p', file_name)
    if match:
        parsed_data = match.groups()
        return {
            "type": parsed_data[0],
            "channel": parsed_data[1]
        }
    return {}

# your_app/serializers.py

from rest_framework import serializers
from .models import YourModel, ValidationRule
from .validators import DynamicFieldValidator
from .utils import parse_file_name

class YourModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = YourModel  # 绑定的模型
        fields = ['id', 'file_name', 'file_metadata']  # 序列化器的字段

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)  # 调用父类的初始化方法
        self.dynamic_validators = {}  # 动态校验器字典
        # 从数据库中读取校验规则
        validation_rules = ValidationRule.objects.all()
        for rule in validation_rules:
            if rule.field_name not in self.dynamic_validators:
                self.dynamic_validators[rule.field_name] = []
            self.dynamic_validators[rule.field_name].append(DynamicFieldValidator(rule.field_name, rule.rule_type, rule.rule_value))

    def validate(self, data):
        # 解析文件名
        parsed_data = parse_file_name(data['file_name'])
        data.update(parsed_data)
        
        # 逐字段应用动态校验
        for field, validators in self.dynamic_validators.items():
            value = data.get(field)
            if value is not None:
                for validator in validators:
                    validator(value)

        # 调用自定义校验方法
        self.custom_validate(data)
        return data

    def custom_validate(self, data):
        # 对于需要自定义校验的字段进行校验
        # 比如：
        if 'type' in data and not data['type'].startswith('thru'):
            raise serializers.ValidationError({'type': 'Invalid type value'})
        # 添加更多自定义校验

    def create(self, validated_data):
        instance = YourModel.objects.create(
            file_name=validated_data['file_name'],
            file_metadata=validated_data.get('file_metadata', {})
        )
        return instance

    def update(self, instance, validated_data):
        instance.file_name = validated_data.get('file_name', instance.file_name)
        instance.file_metadata = validated_data.get('file_metadata', instance.file_metadata)
        instance.save()
        return instance

# your_app/views.py

from rest_framework import viewsets
from .models import YourModel
from .serializers import YourModelSerializer

class YourModelViewSet(viewsets.ModelViewSet):
    queryset = YourModel.objects.all()  # 查询所有 YourModel 实例
    serializer_class = YourModelSerializer  # 使用 YourModelSerializer 序列化器

# your_app/urls.py

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import YourModelViewSet

router = DefaultRouter()
router.register(r'yourmodel', YourModelViewSet)  # 注册 YourModelViewSet 视图集

urlpatterns = [
    path('', include(router.urls)),  # 包含默认路由
]

# your_app/models.py

from django.db import models
from django.contrib.postgres.fields import JSONField

class YourModel(models.Model):
    file_name = models.CharField(max_length=255)  # 文件名字段
    file_metadata = JSONField(blank=True, null=True)  # JSON 字段，用于存储文件元数据

    def __str__(self):
        return self.file_name  # 返回文件名作为字符串表示

class ValidationRule(models.Model):
    field_name = models.CharField(max_length=255)  # 需要校验的字段名称
    rule_type = models.CharField(max_length=255)  # 校验规则类型，例如 'regex' 或 'min_length'
    rule_value = models.CharField(max_length=255)  # 校验规则的具体值，例如正则表达式或最小长度

    def __str__(self):
        return f"{self.field_name} - {self.rule_type}: {self.rule_value}"  # 返回校验规则的字符串表示

# your_app/validators.py

import re
from rest_framework import serializers

class DynamicFieldValidator:
    def __init__(self, field_name, rule_type, rule_value):
        self.field_name = field_name  # 字段名称
        self.rule_type = rule_type  # 校验规则类型
        self.rule_value = rule_value  # 校验规则的具体值

    def __call__(self, value):
        if self.rule_type == 'regex':
            if not re.match(self.rule_value, value):
                raise serializers.ValidationError(f"{self.field_name} does not match pattern {self.rule_value}")
        elif self.rule_type == 'min_length':
            if len(value) < int(self.rule_value):
                raise serializers.ValidationError(f"{self.field_name} length is less than {self.rule_value}")
        # 可以添加更多规则类型

# your_app/utils.py

import re

def parse_file_name(file_name):
    match = re.match(r'\[(.*?)\]-(.*?)\.s4p', file_name)
    if match:
        parsed_data = match.groups()
        return {
            "type": parsed_data[0],
            "channel": parsed_data[1]
        }
    return {}

# your_app/serializers.py

from rest_framework import serializers
from .models import YourModel, ValidationRule
from .validators import DynamicFieldValidator
from .utils import parse_file_name

class YourModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = YourModel  # 绑定的模型
        fields = ['id', 'file_name', 'file_metadata']  # 序列化器的字段

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)  # 调用父类的初始化方法
        self.dynamic_validators = {}  # 动态校验器字典
        # 从数据库中读取校验规则
        validation_rules = ValidationRule.objects.all()
        for rule in validation_rules:
            if rule.field_name not in self.dynamic_validators:
                self.dynamic_validators[rule.field_name] = []
            self.dynamic_validators[rule.field_name].append(DynamicFieldValidator(rule.field_name, rule.rule_type, rule.rule_value))

    def validate(self, data):
        # 解析文件名
        parsed_data = parse_file_name(data['file_name'])
        data.update(parsed_data)

        errors = {}  # 用于存储错误信息

        # 逐字段应用动态校验
        for field, validators in self.dynamic_validators.items():
            value = data.get(field)
            if value is not None:
                for validator in validators:
                    try:
                        validator(value)
                    except serializers.ValidationError as e:
                        errors[field] = str(e)

        # 调用自定义校验方法
        self.custom_validate(data, errors)

        if errors:
            raise serializers.ValidationError(errors)

        return data

    def custom_validate(self, data, errors):
        # 对于需要自定义校验的字段进行校验
        # 比如：
        if 'type' in data and not data['type'].startswith('thru'):
            errors['type'] = 'Invalid type value'
        # 添加更多自定义校验

    def create(self, validated_data):
        instance = YourModel.objects.create(
            file_name=validated_data['file_name'],
            file_metadata=validated_data.get('file_metadata', {})
        )
        return instance

    def update(self, instance, validated_data):
        instance.file_name = validated_data.get('file_name', instance.file_name)
        instance.file_metadata = validated_data.get('file_metadata', instance.file_metadata)
        instance.save()
        return instance

# your_app/views.py

from rest_framework import viewsets
from .models import YourModel
from .serializers import YourModelSerializer

class YourModelViewSet(viewsets.ModelViewSet):
    queryset = YourModel.objects.all()  # 查询所有 YourModel 实例
    serializer_class = YourModelSerializer  # 使用 YourModelSerializer 序列化器

# your_app/urls.py

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import YourModelViewSet

router = DefaultRouter()
router.register(r'yourmodel', YourModelViewSet)  # 注册 YourModelViewSet 视图集

urlpatterns = [
    path('', include(router.urls)),  # 包含默认路由
]

# your_app/models.py

from django.db import models
from django.contrib.postgres.fields import JSONField
import uuid

class YourModel(models.Model):
    uuid = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
    file_name = models.CharField(max_length=255)
    file_metadata = JSONField(blank=True, null=True)
    is_deleted = models.BooleanField(default=False)

    def __str__(self):
        return self.file_name

class FieldInfo(models.Model):
    field_name = models.CharField(max_length=255)
    is_unique_together = models.BooleanField(default=False)

    def __str__(self):
        return f"{self.field_name} - {'Unique Together' if self.is_unique_together else 'Not Unique Together'}"

# your_app/validators.py

import re
from rest_framework import serializers

class DynamicFieldValidator:
    def __init__(self, field_name, rule_type, rule_value):
        self.field_name = field_name
        self.rule_type = rule_type
        self.rule_value = rule_value

    def __call__(self, value):
        if self.rule_type == 'regex':
            if not re.match(self.rule_value, value):
                raise serializers.ValidationError(f"{self.field_name} does not match pattern {self.rule_value}")
        elif self.rule_type == 'min_length':
            if len(value) < int(self.rule_value):
                raise serializers.ValidationError(f"{self.field_name} length is less than {self.rule_value}")
        # 可以添加更多规则类型

# your_app/utils.py

import re

def parse_file_name(file_name):
    match = re.match(r'\[(.*?)\]-(.*?)\.s4p', file_name)
    if match:
        parsed_data = match.groups()
        return {
            "type": parsed_data[0],
            "channel": parsed_data[1]
        }
    return {}

# your_app/serializers.py

from rest_framework import serializers
from .models import YourModel, FieldInfo
from .validators import DynamicFieldValidator
from .utils import parse_file_name
import uuid

class YourModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = YourModel
        fields = ['id', 'uuid', 'file_name', 'file_metadata', 'is_deleted']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.dynamic_validators = {}
        validation_rules = FieldInfo.objects.all()
        for rule in validation_rules:
            if rule.field_name not in self.dynamic_validators:
                self.dynamic_validators[rule.field_name] = []
            self.dynamic_validators[rule.field_name].append(DynamicFieldValidator(rule.field_name, 'regex', r'.*'))  # 示例：默认使用regex规则，实际情况中应从数据库读取

        # 动态生成unique_together字段
        self.unique_together_fields = []
        field_infos = FieldInfo.objects.filter(is_unique_together=True)
        for field_info in field_infos:
            self.unique_together_fields.append(field_info.field_name)

    def validate(self, data):
        # 解析文件名
        parsed_data = parse_file_name(data['file_name'])
        data.update(parsed_data)

        errors = {}

        # 逐字段应用动态校验
        for field, validators in self.dynamic_validators.items():
            value = data.get(field)
            if value is not None:
                for validator in validators:
                    try:
                        validator(value)
                    except serializers.ValidationError as e:
                        errors[field] = str(e)

        # 检查动态unique_together约束
        unique_filter = {field: data[field] for field in self.unique_together_fields}
        if YourModel.objects.filter(**unique_filter, is_deleted=False).exists():
            existing_instance = YourModel.objects.get(**unique_filter, is_deleted=False)
            data['uuid'] = existing_instance.uuid
            data['is_deleted'] = False
        else:
            data['uuid'] = uuid.uuid4()

        if errors:
            raise serializers.ValidationError(errors)

        return data

# your_app/views.py

from rest_framework import viewsets, status
from rest_framework.response import Response
from rest_framework.decorators import api_view
from .models import YourModel
from .serializers import YourModelSerializer

@api_view(['POST'])
def validate_data(request):
    serializer = YourModelSerializer(data=request.data)
    if serializer.is_valid():
        return Response(serializer.data, status=status.HTTP_200_OK)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

@api_view(['POST'])
def save_data(request):
    serializer = YourModelSerializer(data=request.data)
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

# your_app/urls.py

from django.urls import path
from .views import validate_data, save_data

urlpatterns = [
    path('yourmodel/validate/', validate_data, name='validate_data'),
    path('yourmodel/save/', save_data, name='save_data'),
]

# your_app/models.py

from django.db import models
from django.contrib.postgres.fields import JSONField
import uuid

class YourModel(models.Model):
    uuid = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
    file_name = models.CharField(max_length=255)
    file_metadata = JSONField(blank=True, null=True)
    is_deleted = models.BooleanField(default=False)

    def __str__(self):
        return self.file_name

class FieldInfo(models.Model):
    field_name = models.CharField(max_length=255)
    is_unique_together = models.BooleanField(default=False)

    def __str__(self):
        return f"{self.field_name} - {'Unique Together' if self.is_unique_together else 'Not Unique Together'}"

# your_app/validators.py

import re
from rest_framework import serializers

class DynamicFieldValidator:
    def __init__(self, field_name, rule_type, rule_value):
        self.field_name = field_name
        self.rule_type = rule_type
        self.rule_value = rule_value

    def __call__(self, value):
        if self.rule_type == 'regex':
            if not re.match(self.rule_value, value):
                raise serializers.ValidationError(f"{self.field_name} does not match pattern {self.rule_value}")
        elif self.rule_type == 'min_length':
            if len(value) < int(self.rule_value):
                raise serializers.ValidationError(f"{self.field_name} length is less than {self.rule_value}")
        # 可以添加更多规则类型

# your_app/utils.py

import re

def parse_file_name(file_name):
    match = re.match(r'\[(.*?)\]-(.*?)\.s4p', file_name)
    if match:
        parsed_data = match.groups()
        return {
            "type": parsed_data[0],
            "channel": parsed_data[1]
        }
    return {}

# your_app/serializers.py

from rest_framework import serializers
from .models import YourModel, FieldInfo
from .validators import DynamicFieldValidator
from .utils import parse_file_name
import uuid

class YourModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = YourModel
        fields = ['id', 'uuid', 'file_name', 'file_metadata', 'is_deleted']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.dynamic_validators = {}
        validation_rules = FieldInfo.objects.all()
        for rule in validation_rules:
            if rule.field_name not in self.dynamic_validators:
                self.dynamic_validators[rule.field_name] = []
            self.dynamic_validators[rule.field_name].append(DynamicFieldValidator(rule.field_name, 'regex', r'.*'))  # 示例：默认使用regex规则，实际情况中应从数据库读取

        # 动态生成unique_together字段
        self.unique_together_fields = []
        field_infos = FieldInfo.objects.filter(is_unique_together=True)
        for field_info in field_infos:
            self.unique_together_fields.append(field_info.field_name)

    def validate(self, data):
        # 解析文件名
        parsed_data = parse_file_name(data['file_name'])
        data.update(parsed_data)

        errors = {}

        # 逐字段应用动态校验
        for field, validators in self.dynamic_validators.items():
            value = data.get(field)
            if value is not None:
                for validator in validators:
                    try:
                        validator(value)
                    except serializers.ValidationError as e:
                        errors[field] = str(e)

        if errors:
            raise serializers.ValidationError(errors)

        return data

    def create(self, validated_data):
        unique_filter = {field: validated_data[field] for field in self.unique_together_fields}
        if YourModel.objects.filter(**unique_filter, is_deleted=False).exists():
            existing_instance = YourModel.objects.get(**unique_filter, is_deleted=False)
            existing_instance.is_deleted = True
            existing_instance.save()
            validated_data['uuid'] = existing_instance.uuid
        return super().create(validated_data)

    def update(self, instance, validated_data):
        unique_filter = {field: validated_data[field] for field in self.unique_together_fields}
        if YourModel.objects.filter(**unique_filter, is_deleted=False).exists():
            existing_instance = YourModel.objects.get(**unique_filter, is_deleted=False)
            existing_instance.is_deleted = True
            existing_instance.save()
        return super().create(validated_data)

# your_app/views.py

from rest_framework import viewsets, status
from rest_framework.response import Response
from rest_framework.decorators import api_view
from .models import YourModel
from .serializers import YourModelSerializer

@api_view(['POST'])
def validate_data(request):
    serializer = YourModelSerializer(data=request.data, many=True)
    if serializer.is_valid():
        return Response(serializer.data, status=status.HTTP_200_OK)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

@api_view(['POST'])
def save_data(request):
    serializer = YourModelSerializer(data=request.data, many=True)
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

# your_app/urls.py

from django.urls import path
from .views import validate_data, save_data

urlpatterns = [
    path('yourmodel/validate/', validate_data, name='validate_data'),
    path('yourmodel/save/', save_data, name='save_data'),
]

# your_app/serializers.py

from rest_framework import serializers
from .models import YourModel, FieldInfo
from .validators import DynamicFieldValidator
from .utils import parse_file_name
import uuid

class YourModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = YourModel
        fields = ['id', 'uuid', 'file_name', 'file_metadata', 'is_deleted']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.dynamic_validators = {}
        validation_rules = FieldInfo.objects.all()
        for rule in validation_rules:
            if rule.field_name not in self.dynamic_validators:
                self.dynamic_validators[rule.field_name] = []
            self.dynamic_validators[rule.field_name].append(DynamicFieldValidator(rule.field_name, 'regex', r'.*'))

        self.unique_together_fields = []
        field_infos = FieldInfo.objects.filter(is_unique_together=True)
        for field_info in field_infos:
            self.unique_together_fields.append(field_info.field_name)

    def validate(self, data):
        parsed_data = parse_file_name(data['file_name'])
        data.update(parsed_data)

        errors = {}
        for field, validators in self.dynamic_validators.items():
            value = data.get(field)
            if value is not None:
                for validator in validators:
                    try:
                        validator(value)
                    except serializers.ValidationError as e:
                        errors[field] = str(e)

        unique_filter = {field: data[field] for field in self.unique_together_fields}
        existing_instance = YourModel.objects.filter(**unique_filter, is_deleted=False).first()
        if existing_instance:
            data['uuid'] = existing_instance.uuid
            data['is_deleted'] = False
        else:
            data['uuid'] = uuid.uuid4()

        if errors:
            raise serializers.ValidationError(errors)

        return data

    def create(self, validated_data):
        unique_filter = {field: validated_data[field] for field in self.unique_together_fields}
        YourModel.objects.filter(**unique_filter).update(is_deleted=True)
        return YourModel.objects.create(**validated_data)

class BulkYourModelSerializer(serializers.ListSerializer):
    def create(self, validated_data):
        instances = []
        for data in validated_data:
            serializer = YourModelSerializer(data=data)
            serializer.is_valid(raise_exception=True)
            instances.append(serializer.save())
        return instances

# your_app/views.py

from rest_framework import status
from rest_framework.decorators import api_view
from rest_framework.response import Response
from .models import YourModel
from .serializers import YourModelSerializer, BulkYourModelSerializer

@api_view(['POST'])
def validate_data(request):
    serializer = YourModelSerializer(data=request.data, many=True)
    if serializer.is_valid():
        return Response(serializer.data, status=status.HTTP_200_OK)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

@api_view(['POST'])
def save_data(request):
    serializer = BulkYourModelSerializer(data=request.data, many=True)
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

# your_app/urls.py

from django.urls import path
from .views import validate_data, save_data

urlpatterns = [
    path('yourmodel/validate/', validate_data, name='validate_data'),
    path('yourmodel/save/', save_data, name='save_data'),
]

# your_app/serializers.py

from rest_framework import serializers
from .models import YourModel, FieldInfo
from .validators import DynamicFieldValidator
from .utils import parse_file_name
import uuid

class YourModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = YourModel
        fields = ['id', 'uuid', 'file_name', 'file_metadata', 'is_deleted']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.dynamic_validators = {}
        validation_rules = FieldInfo.objects.all()
        for rule in validation_rules:
            if rule.field_name not in self.dynamic_validators:
                self.dynamic_validators[rule.field_name] = []
            self.dynamic_validators[rule.field_name].append(DynamicFieldValidator(rule.field_name, 'regex', r'.*'))

        self.unique_together_fields = []
        field_infos = FieldInfo.objects.filter(is_unique_together=True)
        for field_info in field_infos:
            self.unique_together_fields.append(field_info.field_name)

    def validate(self, data):
        parsed_data = parse_file_name(data['file_name'])
        data.update(parsed_data)

        errors = {}
        for field, validators in self.dynamic_validators.items():
            value = data.get(field)
            if value is not None:
                for validator in validators:
                    try:
                        validator(value)
                    except serializers.ValidationError as e:
                        errors[field] = str(e)

        unique_filter = {field: data[field] for field in self.unique_together_fields}
        if YourModel.objects.filter(**unique_filter, is_deleted=False).exists():
            existing_instance = YourModel.objects.get(**unique_filter, is_deleted=False)
            data['uuid'] = existing_instance.uuid
            data['is_deleted'] = False
        else:
            data['uuid'] = uuid.uuid4()

        if errors:
            raise serializers.ValidationError(errors)

        return data

    def create(self, validated_data):
        unique_filter = {field: validated_data[field] for field in self.unique_together_fields}
        YourModel.objects.filter(**unique_filter).update(is_deleted=True)
        return YourModel.objects.create(**validated_data)

class BulkYourModelSerializer(serializers.ListSerializer):
    def create(self, validated_data):
        instances = []
        for data in validated_data:
            serializer = YourModelSerializer(data=data)
            serializer.is_valid(raise_exception=True)
            instances.append(serializer.save())
        return instances