Switching "with_respect_to" model breaks ordering about django-ordered-model HOT 8 CLOSED

def bottom(self):
    last = (
        self.get_ordering_queryset()
            .exclude(id=self.id)
            .aggregate(Max('order'))
            .get('order__max')
    )

    self.to(last + 1)

def save(self, *args, **kwargs):
    old_active_value = MyModel.objects.get(id=self.id).active

    super().save(*args, **kwargs)

    if self.active is not old_active_value:
        self.bottom()

def bottom(self):
    # Looks for the max value for 'order' in a given subset, or 0 if the subset is empty
    last = (
        self.get_ordering_queryset()
            .exclude(id=self.id)
            .aggregate(Max('order'))
            .get('order__max')
    ) or 0

    self.to(last + 1)

def save(self, *args, **kwargs):
    # If this instance is being created for the first time, old instance won't exist
    try:
        old_instance = MyModel.objects.get(id=self.id)
    except MyModel.DoesNotExist:
        old_instance = None

    super().save(*args, **kwargs)

    if old_instance is not None and self.active is not old_instance.active:
        # If active changed, the instance is switching to a different subset,
        # when need to send that instance to the bottom of that subset.
        self.bottom()

        try:
            # If there was an object after the instance in the OLD subset, move it to the
            # instance's old spot.
            MyModel.objects
                .get(active=old_instance.active, order=old_instance.order + 1)
                .to(old_instance.order)
        except MyModel.DoesNotExist:
            pass

  def save(self, *args, **kwargs):
        if getattr(self, 'id') is not None:
            # This is an existing object, so we need to check if any order_with_respect_to field has changed.
            if isinstance(self.order_with_respect_to, str): # Single order_with_respect_to field.
                order_with_respect_to_fields = [self.order_with_respect_to]
            else:   # Multiple order_with_respect_to fields.
                order_with_respect_to_fields = self.order_with_respect_to
            for field in order_with_respect_to_fields:
                current_respect_field = getattr(self, field)
                old_instance = self.__class__.objects.get(id=getattr(self, 'id'))
                old_respect_field = getattr(old_instance, field)
                if old_respect_field != current_respect_field:
                    old_instance.bottom()
                    setattr(self, self.order_field_name, None)
                    break

        super().save(*args, **kwargs)

from django.db import models
from ordered_model.models import OrderedModelBase


class BaseOrderedModel(OrderedModelBase):
    index = models.PositiveIntegerField(db_index=True, editable=False, verbose_name='index')
    order_field_name = "index"

    class Meta:
        abstract = True
        ordering = ("index", )

    def save(self, *args, **kwargs):
        current_respect_field = getattr(self, self.order_with_respect_to)
        if getattr(self, 'id') is not None:
            # when update existing instance
            old_instance = self.__class__.objects.get(id=getattr(self, 'id'))
            old_respect_field = getattr(old_instance, self.order_with_respect_to)
            if old_respect_field != current_respect_field:
                # if order_with_respect_to field has changed
                # 1. set instance to bottom of old subset before save
                old_instance.bottom()

                # 2. set self.[order_field_name] to None and save instance
                setattr(self, self.order_field_name, None)
                super().save(*args, **kwargs)
            else:
                # if order_with_respect_to field hasn't changed
                super().save(*args, **kwargs)
        else:
            # when create new instance
            super().save(*args, **kwargs)

class Category(BaseOrderedModel):
    id = models.BigAutoField(primary_key=True)
    name = models.CharField(max_length=50, verbose_name="名称")

    parent_category = models.ForeignKey('self', null=True, blank=True, on_delete=models.SET_NULL, verbose_name='parent category')

    order_with_respect_to = 'parent_category'

    class Meta(BaseOrderedModel.Meta):
        ordering = ('parent_category__id', 'index', )

    def __str__(self):
        return self.name

    def save(self, *args, **kwargs):
        if getattr(self, 'id') is not None:
            for field in self.order_with_respect_to:
                current_respect_field = getattr(self, field)
                # when update existing instance
                old_instance = self.__class__.objects.get(id=getattr(self, 'id'))
                old_respect_field = getattr(old_instance, field)
                if old_respect_field != current_respect_field:
                    old_instance.bottom()

                    setattr(self, self.order_field_name, None)
                    super().save(*args, **kwargs)
                    break
        else:
            # when create new instance
            super().save(*args, **kwargs)