🗂️Category API

import { OzonSellerAPI } from 'daytona-ozon-seller-api';

const client = new OzonSellerAPI({
  clientId: 'your-client-id',
  apiKey: 'your-api-key'
});

// Базовый workflow работы с категориями
try {
  // 1. Получить дерево категорий
  const categoryTree = await client.category.getCategoryTree({
    language: 'RU'
  });

  console.log('🌳 Дерево категорий загружено');

  // 2. Найти категории для создания товаров (конечные узлы)
  const findLeafCategories = (items: any[]): any[] => {
    const leafCategories: any[] = [];
    items.forEach(item => {
      if ((!item.children || item.children.length === 0) && !item.disabled) {
        leafCategories.push(item);
      } else if (item.children) {
        leafCategories.push(...findLeafCategories(item.children));
      }
    });
    return leafCategories;
  };

  const leafCategories = findLeafCategories(categoryTree.result || []);
  console.log(`📂 Доступно категорий для создания товаров: ${leafCategories.length}`);

  if (leafCategories.length > 0) {
    const selectedCategory = leafCategories[0];
    console.log(`\n🎯 Выбрана категория: ${selectedCategory.category_name}`);
    console.log(`   ID категории: ${selectedCategory.description_category_id}`);
    console.log(`   ID типа: ${selectedCategory.type_id}`);

    // 3. Получить характеристики категории
    const attributes = await client.category.getCategoryAttributes({
      description_category_id: selectedCategory.description_category_id,
      type_id: selectedCategory.type_id,
      language: 'RU'
    });

    console.log(`\n📋 Характеристик в категории: ${attributes.result?.length || 0}`);

    // 4. Найти характеристики со справочниками значений
    const dictionaryAttributes = attributes.result?.filter(attr => 
      attr.dictionary_id && attr.dictionary_id > 0
    ) || [];

    console.log(`📖 Характеристик со справочниками: ${dictionaryAttributes.length}`);
  }

} catch (error) {
  console.error('❌ Ошибка работы с категориями:', error);
}

// Анализ характеристик категории
const analyzeCategoryAttributes = async (categoryId: number, typeId: number) => {
  try {
    const attributes = await client.category.getCategoryAttributes({
      description_category_id: categoryId,
      type_id: typeId,
      language: 'RU'
    });
    
    const analysis = {
      total: attributes.result?.length || 0,
      required: 0,
      optional: 0,
      collections: 0,
      aspects: 0,
      withDictionary: 0,
      withoutDictionary: 0,
      groups: new Set()
    };
    
    const requiredAttributes: any[] = [];
    const dictionaryAttributes: any[] = [];
    
    attributes.result?.forEach(attr => {
      // Базовая статистика
      if (attr.is_required) {
        analysis.required++;
        requiredAttributes.push(attr);
      } else {
        analysis.optional++;
      }
      
      if (attr.is_collection) analysis.collections++;
      if (attr.is_aspect) analysis.aspects++;
      
      // Справочники
      if (attr.dictionary_id && attr.dictionary_id > 0) {
        analysis.withDictionary++;
        dictionaryAttributes.push(attr);
      } else {
        analysis.withoutDictionary++;
      }
      
      // Группы
      if (attr.group_name) {
        analysis.groups.add(attr.group_name);
      }
    });
    
    console.log('📊 Анализ характеристик категории:');
    console.log(`   Всего характеристик: ${analysis.total}`);
    console.log(`   Обязательных: ${analysis.required}`);
    console.log(`   Необязательных: ${analysis.optional}`);
    console.log(`   Со справочником: ${analysis.withDictionary}`);
    console.log(`   Групп характеристик: ${analysis.groups.size}`);
    
    return { analysis, requiredAttributes, dictionaryAttributes };
    
  } catch (error) {
    console.error('❌ Ошибка анализа характеристик:', error);
  }
};

// Валидация товара по категории
const validateProductForCategory = async (categoryId: number, typeId: number, productData: any) => {
  try {
    const attributes = await client.category.getCategoryAttributes({
      description_category_id: categoryId,
      type_id: typeId,
      language: 'RU'
    });
    
    const requiredAttributes = attributes.result?.filter(attr => attr.is_required) || [];
    const errors: string[] = [];
    const warnings: string[] = [];
    
    console.log(`🔍 Валидация товара для категории ${categoryId}...`);
    
    // Проверка обязательных характеристик
    for (const attr of requiredAttributes) {
      const value = productData[attr.name] || productData[attr.id];
      
      if (!value) {
        errors.push(`Отсутствует обязательная характеристика: ${attr.name}`);
      } else if (attr.dictionary_id && attr.dictionary_id > 0) {
        // Проверка значения из справочника
        try {
          const searchResult = await client.category.searchCategoryAttributeValues({
            attribute_id: attr.id,
            description_category_id: categoryId,
            type_id: typeId,
            value: value.toString(),
            limit: 1
          });
          
          const exactMatch = searchResult.result?.find(v => 
            v.value?.toLowerCase() === value.toString().toLowerCase()
          );
          
          if (!exactMatch) {
            warnings.push(`Значение "${value}" не найдено в справочнике для "${attr.name}"`);
          }
        } catch (error) {
          warnings.push(`Не удалось проверить значение для "${attr.name}"`);
        }
      }
    }
    
    const isValid = errors.length === 0;
    
    console.log(`${isValid ? '✅' : '❌'} Валидация завершена:`);
    console.log(`   Ошибок: ${errors.length}`);
    console.log(`   Предупреждений: ${warnings.length}`);
    
    return { isValid, errors, warnings, requiredAttributesCount: requiredAttributes.length };
    
  } catch (error) {
    console.error('❌ Ошибка валидации товара:', error);
    return {
      isValid: false,
      errors: [`Ошибка валидации: ${error.message}`],
      warnings: [],
      requiredAttributesCount: 0
    };
  }
};