Validation of the serial number against the mask in Django rest

There are two tables - equipment type and equipment, the type has a line with a serial number mask, the equipment has a line with a serial number. When creating new equipment, validation must go through, that is, the string with the serial number is compared with each mask of the equipment type, and if a match is found, the equipment is tied to the type, the question is, how is it better to implement this on the django rest framework?

The check is carried out according to the principle:

N is a number from 0 to 9;
A is a capital letter of the Latin alphabet;
a is a lowercase letter of the Latin alphabet;
X is a capital letter of the Latin alphabet or a number from 0 to 9;
Z is a character from the list: “-“, “_”, “@”

That is, if the equipment has a serial number of 0QWER9@123, it corresponds to a mask with characters like NAAAAXZXXX

models.py

from django.db import models
from django.core.validators import MinLengthValidator
from django.core.validators import RegexValidator
class Type_Of_Equipment(models.Model):
    name = models.CharField(verbose_name='Тип оборудования', max_length=64, blank=True, default='Без названия')
    sn_mask = models.CharField(verbose_name='Маска серийного номера', blank=False, max_length=10,
    validators=[MinLengthValidator(10), RegexValidator(regex=r'^[NAaXZ]+$', message='Использованы недопустимые символы')])    

class Equipment(models.Model):
    code = models.CharField(verbose_name='Код типа оборудования', max_length=64, blank=True)
    sn_number = models.CharField(verbose_name='Серийный номер', max_length=10, blank=False, unique=True, validators=[MinLengthValidator(10), RegexValidator(regex=r'^[A-Za-z0-9-_@]+$', message='Использованы недопустимые символы')]) 
    type_of_equipment = models.ForeignKey(Type_Of_Equipment, on_delete=models.DO_NOTHING)   
    is_deleted = models.BooleanField(default=False)

    # Заготовки для мягкого удаления.
    def soft_delete(self):
        self.is_deleted = True
        self.save()
    def restore(self):
        self.is_deleted = False
        self.save()

views.py

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .serializers import EquipmentSerializer, TypeOfEquipmentSerializer
from .models import Equipment, Type_Of_Equipment
from django.http import Http404

import re

class GetOrCreateEquip(APIView):
    # Получение всего оборудования
    def get(self, request):
        # Получать список с query-параметрами
        equip = Equipment.objects.filter(is_deleted=False)
        code_query = request.query_params.get('code')
        sn_number_query = request.query_params.get('sn_mask')

        if code_query:
            equip = equip.filter(code=code_query)

        elif sn_number_query:
            equip = equip.filter(sn_number=sn_number_query)            

        serializer = EquipmentSerializer(equip, many=True)
        return Response(serializer.data)

    # Создание нового оборудования
    def post(self, request):
        # Создавать объект, только если серийный номер совпадает с маской 
        # Перенести логику валидации данных в функцию clean в моделях?
        sn_shifer = {'N': r'^[0-9]+$',
            'A': r'^[A-Z]+$',
            'a': r'^[a-z]+$',
            'X': r'^[A-Z0-9]+$',
            'Z': r"^[-|_|@]+$"
        }

        success = 0

        for equip in request.data:
        # Логика поиска нужного типа оборудования под серийный номер
            types_of_equipment = Type_Of_Equipment.objects.all()
            equip_sn = equip.get('sn_number')
            for type_of_equipment in types_of_equipment:
                for i in range(10):

                    if re.match(sn_shifer[type_of_equipment.sn_mask[i]], equip_sn[i]):

                        success += 1
                        if success == 10:
                            request.data["type_of_equipment"] = type_of_equipment
                            serializer = EquipmentSerializer(data=request.data, many=True)
                            if serializer.is_valid():
                                serializer.save()
                                return Response(serializer.data, status=201)

                            return Response(serializer.errors, status=400)
                    else:
                        success = 0
                        break

I tried to implement this in models through the clean function, but someone recommended me to do it through views, I apologize in advance for the terrible code, I try to be better.

First of all, there is one clash in your Mask, meaning there will be more than one version for the same type since:

A is a capital letter of the Latin alphabet;
...
X is a capital letter of the Latin alphabet or a number from 0 to 9;

More precisely 0QWER9@123 corresponds to NAAAAXZXXX but also to NAAAANZNNN. Unless you impose some condition, which I will do in my example in order to obtain the desired result (Only the first numeric element gets 'N' the others will get 'X').

Now, to answer your question. I believe an elegant way to implement this would be to write a custom validator that you can place in a separate file:

validators.py

def validate_sn_mask(value):
    mask = ""
    special_list = ["-", "_", "@"]
    first_number = True

    for character in value:
        if character.isnumeric():
            if first_number:
                mask += "N"
                first_number = False
            else:
                mask += "X"
        elif character.isalpha():
            if character.isupper():
                mask += "A"
            else:
                mask += "a"
        elif character in special_list:
            mask += "Z"
        else:
            # Although you already have a regex in your Model
            raise ValidationError({"msg": "Invalid Mask"})

    qs = Type_Of_Equipment.objects.filter(sn_mask=mask)

    if not qs:
        raise ValidationError({"msg": "Mask has no correspondent type"})

    return qs[0]

serializers.py

class EquipmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Equipment
        fields = ['code', 'sn_number','type_of_equipment']
        extra_kwargs = {
            'type_of_equipment': {'required': False}
        }
    
    def validate(self, attrs):
        equipment_type_instance = validate_sn_mask(attrs['sn_number'])
        attrs['type_of_equipment'] = equipment_type_instance
        return super().validate(attrs)

views.py

class GetOrCreateEquip(APIView):
    def get(self, request):
        ...

    def post(self, request):
        serializer = EquipmentSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data)