itd-sdk-js 1.0.0

package/src/posts.js

@@ -0,0 +1,480 @@
+/**
+ * Модуль работы с постами
+ */
+import fs from 'fs';
+import FormData from 'form-data';
+
+export class PostsManager {
+    /**
+     * Управление постами
+     * 
+     * @param {ITDClient} client - Главный клиент
+     */
+    constructor(client) {
+        this.client = client;
+        this.axios = client.axios;
+    }
+    
+    /**
+     * Создает новый пост
+     * 
+     * @param {string} text - Текст поста
+     * @param {string|null} imagePath - Путь к изображению (опционально)
+     * @returns {Promise<Object|null>} Данные созданного поста или null при ошибке
+     */
+    async createPost(text, imagePath = null) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+        
+        try {
+            // Реальный URL из анализа
+            const postUrl = `${this.client.baseUrl}/api/posts`;
+            
+            // Подготовка данных (реальная структура из анализа)
+            let postData = {
+                content: text,  // Реальное поле называется "content"
+            };
+            
+            // Если есть изображение
+            if (imagePath) {
+                // Сначала загружаем файл через /api/files/upload
+                const uploadedFile = await this.client.files.uploadFile(imagePath);
+                if (!uploadedFile) {
+                    console.error('Ошибка: не удалось загрузить изображение');
+                    return null;
+                }
+                
+                // Затем создаем пост с ID загруженного файла
+                postData.attachments = [uploadedFile.id];
+            }
+            
+            // Создаем пост (с изображением или без)
+            const response = await this.axios.post(postUrl, postData);
+            
+            if (response.status === 200 || response.status === 201) {
+                return response.data;
+            } else {
+                console.error(`Ошибка создания поста: ${response.status} - ${JSON.stringify(response.data)}`);
+                return null;
+            }
+        } catch (error) {
+            console.error('Исключение при создании поста:', error.message);
+            if (error.response) {
+                console.error('Response status:', error.response.status);
+                console.error('Response data:', error.response.data);
+            }
+            return null;
+        }
+    }
+    
+    /**
+     * Получает список постов пользователя или ленту
+     * 
+     * @param {string|null} username - Имя пользователя (null = лента/свои посты)
+     * @param {number} limit - Количество постов
+     * @param {string} sort - Сортировка: "new" (новые), "old" (старые), "popular" (популярные), "trending" (трендовые, аналог popular), "recent" (недавние, аналог new)
+     * @param {string|null} cursor - Курсор для пагинации (из pagination.nextCursor)
+     * @param {string|null} tab - Тип ленты: "popular" (популярные), "following" (из подписок), null (обычная лента)
+     * @param {string|null} type - Альтернативный способ указать тип: "trending" (аналог tab=popular)
+     * @param {string|null} filter - Альтернативный способ указать фильтр: "trending" (аналог tab=popular)
+     * @returns {Promise<Object>} Объект с постами и пагинацией: { posts: [], pagination: {} }
+     * 
+     * @note Параметры type и filter являются альтернативными способами получить те же данные,
+     *       что и tab/sort. Они добавлены для совместимости с различными вариантами API.
+     */
+    async getPosts(username = null, limit = 20, sort = 'new', cursor = null, tab = null, type = null, filter = null) {
+        // Если username не указан и tab указан, запрашиваем ленту - требуется авторизация
+        if (!username && (tab || type || filter) && !await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт для получения ленты');
+            return { posts: [], pagination: {} };
+        }
+        
+        try {
+            let postsUrl;
+            const params = {
+                limit: limit,
+            };
+            
+            if (username) {
+                // Посты конкретного пользователя (публичные, auth не требуется)
+                postsUrl = `${this.client.baseUrl}/api/posts/user/${username}`;
+                params.sort = sort;
+            } else {
+                // Лента (популярные, из подписок, или обычная)
+                postsUrl = `${this.client.baseUrl}/api/posts`;
+                
+                // Приоритет: tab > type > filter > sort
+                if (tab) {
+                    params.tab = tab; // "popular" или "following"
+                } else if (type) {
+                    params.type = type; // "trending" (аналог tab=popular)
+                } else if (filter) {
+                    params.filter = filter; // "trending" (аналог tab=popular)
+                } else {
+                    params.sort = sort; // "new", "old", "popular", "trending", "recent"
+                }
+            }
+            
+            if (cursor) {
+                params.cursor = cursor;
+            }
+            
+            const response = await this.axios.get(postsUrl, { params });
+            
+            if (response.status === 200) {
+                const data = response.data;
+                
+                // Реальная структура: { data: { posts: [...], pagination: {...} } }
+                if (data.data && data.data.posts) {
+                    return {
+                        posts: data.data.posts,
+                        pagination: data.data.pagination || {}
+                    };
+                }
+                
+                // Fallback для других возможных структур
+                if (Array.isArray(data)) {
+                    return { posts: data, pagination: {} };
+                } else if (data.posts && Array.isArray(data.posts)) {
+                    return { posts: data.posts, pagination: data.pagination || {} };
+                }
+                
+                return { posts: [], pagination: {} };
+            } else {
+                console.error(`Ошибка получения постов: ${response.status}`);
+                return { posts: [], pagination: {} };
+            }
+        } catch (error) {
+            console.error('Исключение при получении постов:', error.message);
+            if (error.response) {
+                console.error('Response status:', error.response.status);
+                console.error('Response data:', error.response.data);
+            }
+            return { posts: [], pagination: {} };
+        }
+    }
+    
+    /**
+     * Получает популярные посты (лента популярного)
+     * 
+     * @param {number} limit - Количество постов
+     * @param {string|null} cursor - Курсор для пагинации
+     * @returns {Promise<Object>} Объект с постами и пагинацией: { posts: [], pagination: {} }
+     */
+    async getFeedPopular(limit = 20, cursor = null) {
+        return await this.getPosts(null, limit, 'new', cursor, 'popular');
+    }
+    
+    /**
+     * Получает посты из подписок (лента подписок)
+     * 
+     * @param {number} limit - Количество постов
+     * @param {string|null} cursor - Курсор для пагинации
+     * @returns {Promise<Object>} Объект с постами и пагинацией: { posts: [], pagination: {} }
+     */
+    async getFeedFollowing(limit = 20, cursor = null) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт для получения ленты подписок');
+            return { posts: [], pagination: {} };
+        }
+        return await this.getPosts(null, limit, 'new', cursor, 'following');
+    }
+    
+    
+    /**
+     * Получает конкретный пост по ID
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<Object|null>} Данные поста или null
+     * 
+     * Примечание: Авторизация не требуется для просмотра публичных постов
+     */
+    async getPost(postId) {
+        try {
+            // Реальный URL из анализа
+            const postUrl = `${this.client.baseUrl}/api/posts/${postId}`;
+            const response = await this.axios.get(postUrl);
+            
+            if (response.status === 200) {
+                // Структура ответа: { data: { id, content, comments: [...], ... } }
+                const post = response.data.data || response.data;
+                // Комментарии могут быть вложены в пост
+                return post;
+            } else {
+                console.error(`Ошибка получения поста: ${response.status}`);
+                return null;
+            }
+        } catch (error) {
+            console.error('Исключение при получении поста:', error.message);
+            if (error.response) {
+                console.error('Response status:', error.response.status);
+                console.error('Response data:', error.response.data);
+            }
+            return null;
+        }
+    }
+    
+    /**
+     * Редактирует существующий пост
+     * 
+     * @param {string} postId - ID поста
+     * @param {string} newContent - Новый текст поста
+     * @returns {Promise<Object|null>} Обновленные данные поста или null
+     */
+    async editPost(postId, newContent) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+        
+        try {
+            // Реальный URL из анализа: PUT /api/posts/{id}
+            const editUrl = `${this.client.baseUrl}/api/posts/${postId}`;
+            
+            const postData = {
+                content: newContent,  // Реальное поле называется "content"
+            };
+            
+            const response = await this.axios.put(editUrl, postData);
+            
+            if (response.status === 200) {
+                return response.data;
+            } else {
+                console.error(`Ошибка редактирования поста: ${response.status} - ${JSON.stringify(response.data)}`);
+                return null;
+            }
+        } catch (error) {
+            console.error('Исключение при редактировании поста:', error.message);
+            if (error.response) {
+                console.error('Response status:', error.response.status);
+                console.error('Response data:', error.response.data);
+            }
+            return null;
+        }
+    }
+    
+    /**
+     * Удаляет пост
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<boolean>} True если успешно
+     */
+    async deletePost(postId) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return false;
+        }
+        
+        try {
+            // Реальный URL из анализа
+            const deleteUrl = `${this.client.baseUrl}/api/posts/${postId}`;
+            const response = await this.axios.delete(deleteUrl);
+            
+            if (response.status === 200 || response.status === 204) {
+                return true;
+            } else {
+                console.error(`Ошибка удаления поста: ${response.status}`);
+                if (response.data) {
+                    console.error('Response data:', response.data);
+                }
+                return false;
+            }
+        } catch (error) {
+            console.error('Исключение при удалении поста:', error.message);
+            if (error.response) {
+                console.error('Response status:', error.response.status);
+                console.error('Response data:', error.response.data);
+            }
+            return false;
+        }
+    }
+    
+    /**
+     * Закрепляет пост
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<boolean>} True если успешно
+     */
+    async pinPost(postId) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return false;
+        }
+        
+        try {
+            const pinUrl = `${this.client.baseUrl}/api/posts/${postId}/pin`;
+            const response = await this.axios.post(pinUrl);
+            
+            if (response.status === 200 || response.status === 201) {
+                return true;
+            } else {
+                console.error(`Ошибка закрепления поста: ${response.status}`);
+                if (response.data) {
+                    console.error('Response data:', response.data);
+                }
+                return false;
+            }
+        } catch (error) {
+            console.error('Исключение при закреплении поста:', error.message);
+            if (error.response) {
+                console.error('Response status:', error.response.status);
+                console.error('Response data:', error.response.data);
+            }
+            return false;
+        }
+    }
+    
+    /**
+     * Делает репост
+     * 
+     * @param {string} postId - ID поста для репоста
+     * @param {string|null} comment - Комментарий к репосту (опционально)
+     * @returns {Promise<Object|null>} Данные созданного репоста или null при ошибке
+     */
+    async repost(postId, comment = null) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+        
+        try {
+            const repostUrl = `${this.client.baseUrl}/api/posts/${postId}/repost`;
+            
+            const repostData = {};
+            if (comment !== null && comment !== undefined && comment !== '') {
+                repostData.content = comment;
+            }
+            
+            const response = await this.axios.post(repostUrl, repostData);
+            
+            if (response.status === 200 || response.status === 201) {
+                return response.data;
+            } else {
+                console.error(`Ошибка репоста: ${response.status}`);
+                if (response.data) {
+                    console.error('Response data:', response.data);
+                }
+                return null;
+            }
+        } catch (error) {
+            console.error('Исключение при репосте:', error.message);
+            if (error.response) {
+                console.error('Response status:', error.response.status);
+                console.error('Response data:', error.response.data);
+            }
+            return null;
+        }
+    }
+    
+    // ========== USER-FRIENDLY МЕТОДЫ ==========
+    
+    /**
+     * Получает трендовые посты (удобный метод)
+     * 
+     * @param {number} limit - Количество постов (по умолчанию 20)
+     * @param {string|null} cursor - Курсор для пагинации
+     * @returns {Promise<Object>} { posts: [], pagination: {} }
+     */
+    async getTrendingPosts(limit = 20, cursor = null) {
+        return await this.getPosts(null, limit, 'trending', cursor);
+    }
+    
+    /**
+     * Получает недавние посты (удобный метод)
+     * 
+     * @param {number} limit - Количество постов (по умолчанию 20)
+     * @param {string|null} cursor - Курсор для пагинации
+     * @returns {Promise<Object>} { posts: [], pagination: {} }
+     */
+    async getRecentPosts(limit = 20, cursor = null) {
+        return await this.getPosts(null, limit, 'recent', cursor);
+    }
+    
+    /**
+     * Получает свои посты (удобный метод)
+     * 
+     * @param {number} limit - Количество постов (по умолчанию 20)
+     * @param {string} sort - Сортировка: 'new', 'old', 'popular' (по умолчанию 'new')
+     * @param {string|null} cursor - Курсор для пагинации
+     * @returns {Promise<Object>} { posts: [], pagination: {} }
+     */
+    async getMyPosts(limit = 20, sort = 'new', cursor = null) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт для получения своих постов');
+            return { posts: [], pagination: {} };
+        }
+        // Получаем свой username из профиля
+        const profile = await this.client.users.getMyProfile();
+        if (!profile || !profile.username) {
+            console.error('Ошибка: не удалось получить свой username');
+            return { posts: [], pagination: {} };
+        }
+        return await this.getPosts(profile.username, limit, sort, cursor);
+    }
+    
+    /**
+     * Получает последний пост пользователя (удобный метод)
+     * 
+     * @param {string} username - Имя пользователя
+     * @returns {Promise<Object|null>} Последний пост или null
+     */
+    async getUserLatestPost(username) {
+        const result = await this.getPosts(username, 1, 'new');
+        if (result && result.posts && result.posts.length > 0) {
+            return result.posts[0];
+        }
+        return null;
+    }
+    
+    /**
+     * Получает количество лайков поста (удобный метод)
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<number>} Количество лайков
+     */
+    async getPostLikesCount(postId) {
+        const post = await this.getPost(postId);
+        return post ? (post.likesCount || 0) : 0;
+    }
+    
+    /**
+     * Получает количество просмотров поста (удобный метод)
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<number>} Количество просмотров
+     */
+    async getPostViewsCount(postId) {
+        const post = await this.getPost(postId);
+        return post ? (post.viewsCount || 0) : 0;
+    }
+    
+    /**
+     * Получает количество комментариев поста (удобный метод)
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<number>} Количество комментариев
+     */
+    async getPostCommentsCount(postId) {
+        const post = await this.getPost(postId);
+        return post ? (post.commentsCount || 0) : 0;
+    }
+    
+    /**
+     * Получает статистику поста (удобный метод)
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<Object|null>} { likes: number, views: number, comments: number, reposts: number } или null
+     */
+    async getPostStats(postId) {
+        const post = await this.getPost(postId);
+        if (!post) return null;
+        return {
+            likes: post.likesCount || 0,
+            views: post.viewsCount || 0,
+            comments: post.commentsCount || 0,
+            reposts: post.repostsCount || 0
+        };
+    }
+}

package/src/reports.js

@@ -0,0 +1,97 @@
+/**
+ * Менеджер для работы с репортами (жалобами)
+ */
+export class ReportsManager {
+    constructor(client) {
+        this.client = client;
+        this.axios = client.axios;
+    }
+
+    /**
+     * Отправляет репорт на пост, комментарий или пользователя
+     * 
+     * @param {string} targetType - Тип цели: "post", "comment", "user"
+     * @param {string} targetId - ID цели (поста, комментария или пользователя)
+     * @param {string} reason - Причина репорта (например, "other", "spam", "harassment", "inappropriate")
+     * @param {string} description - Описание проблемы (опционально)
+     * @returns {Promise<Object|null>} { id, createdAt } или null при ошибке
+     */
+    async report(targetType, targetId, reason = 'other', description = '') {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт для отправки репорта');
+            return null;
+        }
+
+        try {
+            const reportUrl = `${this.client.baseUrl}/api/reports`;
+            const payload = {
+                targetType: targetType,
+                targetId: targetId,
+                reason: reason,
+            };
+
+            if (description) {
+                payload.description = description;
+            }
+
+            const response = await this.axios.post(reportUrl, payload);
+
+            if (response.status === 200 || response.status === 201) {
+                // Структура ответа: { data: { id, createdAt } }
+                if (response.data && response.data.data) {
+                    return response.data.data;
+                }
+                return response.data || { success: true };
+            } else {
+                console.error(`Ошибка отправки репорта: ${response.status}`);
+                if (response.data) {
+                    console.error('Response data:', response.data);
+                }
+                return null;
+            }
+        } catch (error) {
+            console.error('Исключение при отправке репорта:', error.message);
+            if (error.response) {
+                console.error('Response status:', error.response.status);
+                console.error('Response data:', error.response.data);
+            }
+            return null;
+        }
+    }
+
+    /**
+     * Отправляет репорт на пост
+     * 
+     * @param {string} postId - ID поста
+     * @param {string} reason - Причина репорта (по умолчанию "other")
+     * @param {string} description - Описание проблемы
+     * @returns {Promise<Object|null>} { id, createdAt } или null при ошибке
+     */
+    async reportPost(postId, reason = 'other', description = '') {
+        return await this.report('post', postId, reason, description);
+    }
+
+    /**
+     * Отправляет репорт на комментарий
+     * 
+     * @param {string} commentId - ID комментария
+     * @param {string} reason - Причина репорта (по умолчанию "other")
+     * @param {string} description - Описание проблемы
+     * @returns {Promise<Object|null>} { id, createdAt } или null при ошибке
+     */
+    async reportComment(commentId, reason = 'other', description = '') {
+        return await this.report('comment', commentId, reason, description);
+    }
+
+    /**
+     * Отправляет репорт на пользователя
+     * 
+     * @param {string} userId - ID пользователя
+     * @param {string} reason - Причина репорта (по умолчанию "other")
+     * @param {string} description - Описание проблемы
+     * @returns {Promise<Object|null>} { id, createdAt } или null при ошибке
+     */
+    async reportUser(userId, reason = 'other', description = '') {
+        return await this.report('user', userId, reason, description);
+    }
+}

package/src/search.js

@@ -0,0 +1,86 @@
+/**
+ * Менеджер для работы с поиском
+ */
+export class SearchManager {
+    constructor(client) {
+        this.client = client;
+        this.axios = client.axios;
+    }
+
+    /**
+     * Выполняет поиск пользователей и хэштегов
+     * 
+     * @param {string} query - Поисковый запрос
+     * @param {number} userLimit - Максимальное количество пользователей (по умолчанию 5)
+     * @param {number} hashtagLimit - Максимальное количество хэштегов (по умолчанию 5)
+     * @returns {Promise<Object|null>} { users: [], hashtags: [] } или null при ошибке
+     */
+    async search(query, userLimit = 5, hashtagLimit = 5) {
+        try {
+            const searchUrl = `${this.client.baseUrl}/api/search/`;
+            const params = {
+                q: query,
+                userLimit: userLimit,
+                hashtagLimit: hashtagLimit,
+            };
+
+            const response = await this.axios.get(searchUrl, { params });
+
+            if (response.status === 200) {
+                const data = response.data;
+                
+                // Структура ответа: { data: { users: [], hashtags: [] } }
+                if (data.data) {
+                    return {
+                        users: data.data.users || [],
+                        hashtags: data.data.hashtags || []
+                    };
+                }
+                
+                // Fallback
+                if (data.users || data.hashtags) {
+                    return {
+                        users: data.users || [],
+                        hashtags: data.hashtags || []
+                    };
+                }
+                
+                return { users: [], hashtags: [] };
+            } else {
+                console.error(`Ошибка поиска: ${response.status}`);
+                return null;
+            }
+        } catch (error) {
+            console.error('Исключение при поиске:', error.message);
+            if (error.response) {
+                console.error('Response status:', error.response.status);
+                console.error('Response data:', error.response.data);
+            }
+            return null;
+        }
+    }
+
+    /**
+     * Ищет пользователей
+     * 
+     * @param {string} query - Поисковый запрос
+     * @param {number} limit - Максимальное количество пользователей (по умолчанию 5)
+     * @returns {Promise<Array|null>} Массив пользователей или null при ошибке
+     */
+    async searchUsers(query, limit = 5) {
+        const result = await this.search(query, limit, 0);
+        return result ? result.users : null;
+    }
+
+    /**
+     * Ищет хэштеги
+     * 
+     * @param {string} query - Поисковый запрос
+     * @param {number} limit - Максимальное количество хэштегов (по умолчанию 5)
+     * @returns {Promise<Array|null>} Массив хэштегов или null при ошибке
+     */
+    async searchHashtags(query, limit = 5) {
+        const result = await this.search(query, 0, limit);
+        return result ? result.hashtags : null;
+    }
+}