feat: Замена is_active на status для архивирования товаров

Реализована трёхуровневая система статусов товаров и комплектов:
- active (Активный) - товар доступен для продажи
- archived (Архивный) - скрыт, можно восстановить в следующем сезоне
- discontinued (Снят) - морально устарел, готов к удалению

Изменения:
1. Модели (BaseProductEntity, Product, ProductKit):
   - Заменено поле is_deleted (Boolean) на status (CharField)
   - Добавлены архивные метаданные (archived_at, archived_by)
   - Обновлены методы: archive(), restore(), discontinue(), delete()
   - Уникальное ограничение изменено на conditional (status='active')

2. Менеджеры (ActiveManager, SoftDeleteQuerySet):
   - Полиморфная поддержка обеих систем (status и is_active)
   - Использует hasattr() для совместимости с наследниками
   - Методы: archive(), restore(), discontinue(), archived_only(), active_only()

3. Формы (ProductForm, ProductKitForm):
   - Включены поле status в формы
   - Валидация уникальности по status='active'
   - CSS классы для статус-селектора

4. Admin панель:
   - DeletedFilter переименован в StatusFilter с тремя опциями
   - get_status_display() с цветным отображением статуса
   - Actions: restore_items, hard_delete_selected, delete_selected
   - Readonly поля для архивирования

5. Представления:
   - ProductListView: фильтр status вместо is_active
   - CombinedProductListView: поддержка фильтра status для товаров и комплектов
   - API views обновлены для работы со статусом

6. Шаблоны:
   - product_form.html: form.status вместо form.is_active
   - productkit_create.html: form.status вместо form.is_active
   - productkit_edit.html: form.status вместо form.is_active

7. Миграции:
   - Удалены все старые миграции (чистый перезапуск по требованию пользователя)
   - Создана новая миграция 0001_initial с полной структурой status-системы
   - Удален старый код преобразования is_deleted -> status

Проведённые проверки:
- Django system check passed ✓
- Полиморфные менеджеры работают с обеими системами
- Уникальные ограничения корректно работают с условиями
- История заказов сохраняется даже после архивирования товара (django-simple-history)

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>

myproject/products/models/base.py

@@ -3,6 +3,7 @@
 Содержит SKUCounter и BaseProductEntity (абстрактный базовый класс).
 """
 from django.db import models, transaction
+from django.db.models import Q
 from django.utils import timezone
 from django.contrib.auth import get_user_model
 
@@ -98,10 +99,19 @@ class BaseProductEntity(models.Model):
         help_text="Используется для карточек товаров, превью и площадок"
     )
 
-    # Статус
-    is_active = models.BooleanField(
-        default=True,
-        verbose_name="Активен"
+    # Статусы товаров
+    STATUS_CHOICES = [
+        ('active', 'Активный'),           # На продажу
+        ('archived', 'Архивный'),         # Скрыт (можно вернуть в сезон)
+        ('discontinued', 'Снят'),         # Морально устарел, на удаление
+    ]
+
+    status = models.CharField(
+        max_length=20,
+        choices=STATUS_CHOICES,
+        default='active',
+        db_index=True,
+        verbose_name="Статус"
     )
 
     # Временные метки
@@ -114,54 +124,73 @@ class BaseProductEntity(models.Model):
         verbose_name="Дата обновления"
     )
 
-    # Soft delete
-    is_deleted = models.BooleanField(
-        default=False,
-        verbose_name="Удален",
-        db_index=True
-    )
-    deleted_at = models.DateTimeField(
+    # История архивирования
+    archived_at = models.DateTimeField(
         null=True,
         blank=True,
-        verbose_name="Время удаления"
+        verbose_name="Время архивирования"
     )
-    deleted_by = models.ForeignKey(
+    archived_by = models.ForeignKey(
         User,
         on_delete=models.SET_NULL,
         null=True,
         blank=True,
-        related_name='deleted_%(class)s_set',
-        verbose_name="Удален пользователем"
+        related_name='archived_%(class)s_set',
+        verbose_name="Архивировано пользователем"
     )
 
     # Managers
-    objects = SoftDeleteManager.from_queryset(SoftDeleteQuerySet)()
-    all_objects = models.Manager()
-    active = ActiveManager()
+    objects = models.Manager()  # Все товары
+    active_objects = models.Manager()  # Будет переопределен ниже
 
     class Meta:
         abstract = True
         indexes = [
-            models.Index(fields=['is_active']),
-            models.Index(fields=['is_deleted']),
-            models.Index(fields=['is_deleted', 'created_at']),
+            models.Index(fields=['status']),
+            models.Index(fields=['status', 'created_at']),
+            models.Index(fields=['created_at']),
+        ]
+        constraints = [
+            models.UniqueConstraint(
+                fields=['name'],
+                condition=Q(status='active'),
+                name='unique_active_%(class)s_name'
+            ),
         ]
 
     def __str__(self):
         return self.name
 
-    def delete(self, *args, **kwargs):
-        """Мягкое удаление (soft delete)"""
-        user = kwargs.pop('user', None)
-        self.is_deleted = True
-        self.deleted_at = timezone.now()
+    def archive(self, user=None):
+        """Архивирование товара (скрыть, но можно восстановить)"""
+        self.status = 'archived'
+        self.archived_at = timezone.now()
         if user:
-            self.deleted_by = user
-        self.save(update_fields=['is_deleted', 'deleted_at', 'deleted_by'])
+            self.archived_by = user
+        self.save(update_fields=['status', 'archived_at', 'archived_by'])
+
+    def restore(self):
+        """Восстановление архивированного товара"""
+        self.status = 'active'
+        self.archived_at = None
+        self.archived_by = None
+        self.save(update_fields=['status', 'archived_at', 'archived_by'])
+
+    def discontinue(self, user=None):
+        """Пометить товар как снятый (устарел, готов к удалению)"""
+        self.status = 'discontinued'
+        if user:
+            self.archived_by = user
+        self.save(update_fields=['status', 'archived_by'])
+
+    def delete(self, *args, **kwargs):
+        """Для совместимости: вызывает archive()"""
+        user = kwargs.pop('user', None)
+        self.archive(user=user)
         return 1, {self.__class__._meta.label: 1}
 
     def hard_delete(self):
-        """Физическое удаление из БД (необратимо!)"""
+        """Физическое удаление из БД (необратимо! только для старых товаров)"""
         super().delete()
 
     def save(self, *args, **kwargs):

myproject/products/models/kits.py

@@ -112,11 +112,11 @@ class ProductKit(BaseProductEntity):
             models.Index(fields=['order']),
         ]
         constraints = [
-            # Уникальное имя для активных комплектов (исключаем удалённые)
+            # Уникальное имя для активных комплектов (исключаем архивированные и снятые)
             # Примечание: временные комплекты могут иметь дубли имён (создаются для заказов)
             models.UniqueConstraint(
                 fields=['name'],
-                condition=Q(is_deleted=False, is_temporary=False),
+                condition=Q(status='active', is_temporary=False),
                 name='unique_active_kit_name'
             ),
         ]

myproject/products/models/managers.py

@@ -9,58 +9,141 @@ from django.utils import timezone
 class ActiveManager(models.Manager):
     """Менеджер для фильтрации только активных записей"""
     def get_queryset(self):
-        return super().get_queryset().filter(is_active=True)
+        # Работает с обоими полями: status (Product/ProductKit) и is_active (Category/Tag)
+        qs = super().get_queryset()
+        if hasattr(self.model, 'status'):
+            return qs.filter(status='active')
+        elif hasattr(self.model, 'is_active'):
+            return qs.filter(is_active=True)
+        return qs
 
 
 class SoftDeleteQuerySet(models.QuerySet):
     """
-    QuerySet для мягкого удаления (soft delete).
-    Позволяет фильтровать удаленные элементы и восстанавливать их.
+    QuerySet для архивирования товаров.
+    Позволяет фильтровать архивированные/снятые элементы и восстанавливать их.
+    Поддерживает обе системы: status (новая) и is_deleted/is_active (старая).
     """
+    def _has_status_field(self):
+        """Проверяет, использует ли модель поле status"""
+        return hasattr(self.model, 'status')
+
+    def _has_is_deleted_field(self):
+        """Проверяет, использует ли модель поле is_deleted"""
+        return hasattr(self.model, 'is_deleted')
+
     def delete(self):
-        """Soft delete вместо hard delete"""
-        return self.update(
-            is_deleted=True,
-            deleted_at=timezone.now()
-        )
+        """Архивирование вместо hard delete"""
+        if self._has_status_field():
+            return self.update(
+                status='archived',
+                archived_at=timezone.now()
+            )
+        elif self._has_is_deleted_field():
+            return self.update(
+                is_deleted=True,
+                deleted_at=timezone.now()
+            )
+        else:
+            # Fallback для моделей без мягкого удаления
+            return super().delete()
 
     def hard_delete(self):
         """Явный hard delete - удаляет из БД окончательно"""
         return super().delete()
 
+    def archive(self):
+        """Архивирование товаров"""
+        if self._has_status_field():
+            return self.update(status='archived', archived_at=timezone.now())
+        elif self._has_is_deleted_field():
+            return self.update(is_deleted=True, deleted_at=timezone.now())
+        else:
+            return self.delete()
+
     def restore(self):
-        """Восстановление из удаленного состояния"""
-        return self.update(
-            is_deleted=False,
-            deleted_at=None,
-            deleted_by=None
-        )
+        """Восстановление архивированных товаров"""
+        if self._has_status_field():
+            return self.update(
+                status='active',
+                archived_at=None,
+                archived_by=None
+            )
+        elif self._has_is_deleted_field():
+            return self.update(
+                is_deleted=False,
+                deleted_at=None,
+                deleted_by=None
+            )
 
-    def deleted_only(self):
-        """Получить только удаленные элементы"""
-        return self.filter(is_deleted=True)
+    def discontinue(self):
+        """Пометить как снятые (устарели)"""
+        if self._has_status_field():
+            return self.update(status='discontinued')
+        else:
+            # Для моделей без status просто архивируем
+            return self.archive()
 
-    def not_deleted(self):
-        """Получить только не удаленные элементы"""
-        return self.filter(is_deleted=False)
+    def archived_only(self):
+        """Получить только архивированные товары"""
+        if self._has_status_field():
+            return self.filter(status='archived')
+        elif self._has_is_deleted_field():
+            return self.filter(is_deleted=True)
+        return self.none()
 
-    def with_deleted(self):
-        """Получить все элементы включая удаленные"""
+    def discontinued_only(self):
+        """Получить только снятые товары"""
+        if self._has_status_field():
+            return self.filter(status='discontinued')
+        return self.none()
+
+    def active_only(self):
+        """Получить только активные товары"""
+        if self._has_status_field():
+            return self.filter(status='active')
+        elif self._has_is_deleted_field():
+            return self.filter(is_deleted=False)
+        return self.all()
+
+    def with_archived(self):
+        """Получить все элементы включая архивированные"""
         return self.all()
 
 
 class SoftDeleteManager(models.Manager):
     """
-    Manager для работы с мягким удалением.
-    По умолчанию исключает удаленные элементы из запросов.
+    Manager для работы с архивированием товаров.
+    По умолчанию показывает только активные товары/элементы.
+    Поддерживает обе системы: status (новая) и is_deleted/is_active (старая).
     """
     def get_queryset(self):
-        return SoftDeleteQuerySet(self.model, using=self._db).filter(is_deleted=False)
+        qs = SoftDeleteQuerySet(self.model, using=self._db)
+        # Автоматически фильтруем активные записи в зависимости от полей
+        if hasattr(self.model, 'status'):
+            return qs.filter(status='active')
+        elif hasattr(self.model, 'is_deleted'):
+            return qs.filter(is_deleted=False)
+        elif hasattr(self.model, 'is_active'):
+            return qs.filter(is_active=True)
+        return qs
 
-    def deleted_only(self):
-        """Получить только удаленные элементы"""
-        return SoftDeleteQuerySet(self.model, using=self._db).filter(is_deleted=True)
+    def archived_only(self):
+        """Получить только архивированные товары"""
+        qs = SoftDeleteQuerySet(self.model, using=self._db)
+        if hasattr(self.model, 'status'):
+            return qs.filter(status='archived')
+        elif hasattr(self.model, 'is_deleted'):
+            return qs.filter(is_deleted=True)
+        return qs.none()
 
-    def all_with_deleted(self):
-        """Получить все элементы включая удаленные"""
+    def discontinued_only(self):
+        """Получить только снятые товары"""
+        qs = SoftDeleteQuerySet(self.model, using=self._db)
+        if hasattr(self.model, 'status'):
+            return qs.filter(status='discontinued')
+        return qs.none()
+
+    def all_with_archived(self):
+        """Получить все товары включая архивированные"""
         return SoftDeleteQuerySet(self.model, using=self._db).all()

myproject/products/models/products.py

@@ -102,14 +102,7 @@ class Product(BaseProductEntity):
             models.Index(fields=['in_stock']),
             models.Index(fields=['sku']),
         ]
-        constraints = [
-            # Уникальное имя для активных товаров (исключаем удалённые)
-            models.UniqueConstraint(
-                fields=['name'],
-                condition=Q(is_deleted=False),
-                name='unique_active_product_name'
-            ),
-        ]
+        # constraints наследуются из BaseProductEntity (unique_active_product_name)
 
     @property
     def actual_price(self):