itd-sdk-js 1.0.0

package/src/comments.js

@@ -0,0 +1,256 @@
+/**
+ * Модуль работы с комментариями
+ */
+export class CommentsManager {
+    /**
+     * Управление комментариями
+     * 
+     * @param {ITDClient} client - Главный клиент
+     */
+    constructor(client) {
+        this.client = client;
+        this.axios = client.axios;
+    }
+    
+    /**
+     * Добавляет комментарий к посту
+     * 
+     * @param {string} postId - ID поста
+     * @param {string} text - Текст комментария
+     * @param {string|null} replyToCommentId - ID комментария для ответа (опционально)
+     * @returns {Promise<Object|null>} Данные созданного комментария или null
+     */
+    async addComment(postId, text, replyToCommentId = null) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+        
+        try {
+            const commentUrl = `${this.client.baseUrl}/api/posts/${postId}/comments`;
+            const commentData = {
+                content: text,  // Реальное поле - content
+            };
+            
+            // Если это ответ на комментарий
+            if (replyToCommentId) {
+                commentData.replyTo = replyToCommentId;
+            }
+            
+            const response = await this.axios.post(commentUrl, commentData);
+            
+            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} postId - ID поста
+     * @param {number} limit - Количество комментариев
+     * @param {string} sort - Сортировка: "popular", "new", "old" (по умолчанию "popular")
+     * @returns {Promise<Object>} { comments: [], total, hasMore, nextCursor } или { comments: [] } при ошибке
+     * 
+     * Примечание: Авторизация не требуется для просмотра комментариев
+     */
+    async getComments(postId, limit = 20, sort = 'popular') {
+        try {
+            const commentsUrl = `${this.client.baseUrl}/api/posts/${postId}/comments`;
+            const params = {
+                limit: limit,
+                sort: sort,
+            };
+            
+            const response = await this.axios.get(commentsUrl, { params });
+            
+            if (response.status === 200) {
+                const data = response.data;
+                // Структура: { data: { comments: [...], total, hasMore, nextCursor } }
+                if (data.data && data.data.comments) {
+                    return {
+                        comments: data.data.comments,
+                        total: data.data.total || 0,
+                        hasMore: data.data.hasMore || false,
+                        nextCursor: data.data.nextCursor || null
+                    };
+                } else if (data.comments) {
+                    return {
+                        comments: data.comments,
+                        total: data.total || 0,
+                        hasMore: data.hasMore || false,
+                        nextCursor: data.nextCursor || null
+                    };
+                } else if (Array.isArray(data)) {
+                    return {
+                        comments: data,
+                        total: data.length,
+                        hasMore: false,
+                        nextCursor: null
+                    };
+                }
+                return { comments: [], total: 0, hasMore: false, nextCursor: null };
+            } else {
+                console.error(`Ошибка получения комментариев: ${response.status}`);
+                return { comments: [], total: 0, hasMore: false, nextCursor: 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 { comments: [], total: 0, hasMore: false, nextCursor: null };
+        }
+    }
+    
+    /**
+     * Ставит лайк на комментарий
+     * 
+     * @param {string} commentId - ID комментария
+     * @returns {Promise<Object|null>} { liked: true, likesCount: number } или null при ошибке
+     */
+    async likeComment(commentId) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+        
+        try {
+            const likeUrl = `${this.client.baseUrl}/api/comments/${commentId}/like`;
+            const response = await this.axios.post(likeUrl);
+            
+            if (response.status === 200 || response.status === 201) {
+                return response.data; // { liked: true, likesCount: number }
+            } else {
+                console.error(`Ошибка лайка комментария: ${response.status} - ${JSON.stringify(response.data)}`);
+                return null;
+            }
+        } catch (error) {
+            console.error('Исключение при лайке комментария:', error.message);
+            if (error.response) {
+                console.error('Response:', error.response.status, error.response.data);
+            }
+            return null;
+        }
+    }
+    
+    /**
+     * Убирает лайк с комментария
+     * 
+     * @param {string} commentId - ID комментария
+     * @returns {Promise<Object|null>} { liked: false, likesCount: number } или null при ошибке
+     */
+    async unlikeComment(commentId) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+        
+        try {
+            const unlikeUrl = `${this.client.baseUrl}/api/comments/${commentId}/like`;
+            const response = await this.axios.delete(unlikeUrl);
+            
+            if (response.status === 200 || response.status === 204) {
+                return response.data || { liked: false, likesCount: 0 };
+            } 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 {number} commentId - ID комментария
+     * @returns {Promise<boolean>} True если успешно
+     */
+    async deleteComment(commentId) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return false;
+        }
+        
+        try {
+            const deleteUrl = `${this.client.baseUrl}/api/comments/${commentId}`;
+            const response = await this.axios.delete(deleteUrl);
+            
+            if (response.status === 200 || response.status === 204) {
+                return true;
+            } else {
+                console.error(`Ошибка удаления комментария: ${response.status}`);
+                return false;
+            }
+        } catch (error) {
+            console.error('Исключение при удалении комментария:', error.message);
+            return false;
+        }
+    }
+    
+    // ========== USER-FRIENDLY МЕТОДЫ ==========
+    
+    /**
+     * Получает количество комментариев поста (удобный метод)
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<number>} Количество комментариев
+     */
+    async getPostCommentsCount(postId) {
+        const result = await this.getComments(postId, 1);
+        if (result && result.total !== undefined) {
+            return result.total;
+        }
+        // Fallback: получаем через пост
+        const post = await this.client.posts.getPost(postId);
+        return post ? (post.commentsCount || 0) : 0;
+    }
+    
+    /**
+     * Получает топ-комментарий поста (с наибольшим количеством лайков) (удобный метод)
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<Object|null>} Топ-комментарий или null
+     */
+    async getTopComment(postId) {
+        const result = await this.getComments(postId, 20, 'popular');
+        if (result && result.comments && result.comments.length > 0) {
+            // Сортируем по лайкам и возвращаем первый
+            const sorted = [...result.comments].sort((a, b) => (b.likesCount || 0) - (a.likesCount || 0));
+            return sorted[0];
+        }
+        return null;
+    }
+    
+    /**
+     * Проверяет, есть ли комментарии у поста (удобный метод)
+     * 
+     * @param {string} postId - ID поста
+     * @returns {Promise<boolean>} True если есть комментарии
+     */
+    async hasComments(postId) {
+        const count = await this.getPostCommentsCount(postId);
+        return count > 0;
+    }
+}

package/src/files.js

@@ -0,0 +1,59 @@
+/**
+ * Модуль для работы с файлами
+ */
+import fs from 'fs';
+import FormData from 'form-data';
+
+export class FilesManager {
+    constructor(client) {
+        this.client = client;
+        this.axios = client.axios;
+    }
+
+    /**
+     * Загружает файл (изображение) на сервер
+     * 
+     * @param {string} filePath - Путь к файлу
+     * @returns {Promise<Object|null>} { id, url, filename, mimeType, size } или null при ошибке
+     */
+    async uploadFile(filePath) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+
+        try {
+            // Проверка существования файла
+            if (!fs.existsSync(filePath)) {
+                console.error(`Ошибка: файл ${filePath} не найден`);
+                return null;
+            }
+
+            const uploadUrl = `${this.client.baseUrl}/api/files/upload`;
+            
+            // Создаем FormData для multipart/form-data
+            const formData = new FormData();
+            formData.append('file', fs.createReadStream(filePath));
+
+            const response = await this.axios.post(uploadUrl, formData, {
+                headers: {
+                    ...formData.getHeaders(),
+                }
+            });
+
+            if (response.status === 200 || response.status === 201) {
+                return response.data; // { id, url, filename, mimeType, size }
+            } 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;
+        }
+    }
+}

package/src/hashtags.js

@@ -0,0 +1,101 @@
+/**
+ * Модуль для работы с хэштегами
+ */
+export class HashtagsManager {
+    constructor(client) {
+        this.client = client;
+        this.axios = client.axios;
+    }
+
+    /**
+     * Получает трендовые хэштеги
+     * 
+     * @param {number} limit - Количество хэштегов (по умолчанию 10)
+     * @returns {Promise<Object|null>} { hashtags: [] } или null при ошибке
+     */
+    async getTrending(limit = 10) {
+        try {
+            const trendingUrl = `${this.client.baseUrl}/api/hashtags/trending`;
+            const params = { limit };
+            const response = await this.axios.get(trendingUrl, { params });
+
+            if (response.status === 200) {
+                const data = response.data;
+                // Структура: { data: { hashtags: [...] } }
+                if (data.data && data.data.hashtags) {
+                    return {
+                        hashtags: data.data.hashtags
+                    };
+                } else if (data.hashtags) {
+                    return {
+                        hashtags: data.hashtags
+                    };
+                }
+                return { 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} hashtagName - Имя хэштега (без #)
+     * @param {number} limit - Количество постов (по умолчанию 20)
+     * @param {string|null} cursor - Курсор для пагинации
+     * @returns {Promise<Object|null>} { posts: [], hashtag: {}, pagination: {} } или null при ошибке
+     */
+    async getPostsByHashtag(hashtagName, limit = 20, cursor = null) {
+        try {
+            // Убираем # если есть
+            const cleanHashtag = hashtagName.replace(/^#/, '');
+            const hashtagUrl = `${this.client.baseUrl}/api/hashtags/${encodeURIComponent(cleanHashtag)}/posts`;
+            
+            const params = { limit };
+            if (cursor) {
+                params.cursor = cursor;
+            }
+
+            const response = await this.axios.get(hashtagUrl, { params });
+
+            if (response.status === 200) {
+                const data = response.data;
+                
+                // Структура: { data: { hashtag: {...} или null, posts: [...], pagination: {...} } }
+                if (data.data) {
+                    return {
+                        hashtag: data.data.hashtag || null,
+                        posts: data.data.posts || [],
+                        pagination: data.data.pagination || {}
+                    };
+                }
+                
+                // Fallback
+                return {
+                    hashtag: null,
+                    posts: data.posts || [],
+                    pagination: data.pagination || {}
+                };
+            } 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;
+        }
+    }
+}

package/src/notifications.js

@@ -0,0 +1,215 @@
+/**
+ * Модуль для работы с уведомлениями
+ */
+export class NotificationsManager {
+    constructor(client) {
+        this.client = client;
+        this.axios = client.axios;
+    }
+
+    /**
+     * Получает список уведомлений
+     * 
+     * @param {number} limit - Количество уведомлений
+     * @param {string|null} cursor - Курсор для пагинации
+     * @param {string|null} type - Фильтр по типу: 'reply', 'like', 'wall_post', 'follow', 'comment' (опционально)
+     * @returns {Promise<Object|null>} { notifications: [], pagination: {} } или null при ошибке
+     */
+    async getNotifications(limit = 20, cursor = null, type = null) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+
+        try {
+            const notificationsUrl = `${this.client.baseUrl}/api/notifications`;
+            const params = { limit };
+            if (cursor) {
+                params.cursor = cursor;
+            }
+            // Пробуем передать type в параметрах (если API поддерживает)
+            if (type) {
+                params.type = type;
+            }
+
+            const response = await this.axios.get(notificationsUrl, { params });
+
+            if (response.status === 200) {
+                const data = response.data;
+                let notifications = [];
+                let pagination = {};
+                
+                // Предполагаемая структура: { data: { notifications: [...], pagination: {...} } }
+                if (data.data && data.data.notifications) {
+                    notifications = data.data.notifications;
+                    pagination = data.data.pagination || {};
+                } else if (Array.isArray(data)) {
+                    notifications = data;
+                } else if (data.notifications) {
+                    notifications = data.notifications;
+                    pagination = data.pagination || {};
+                }
+                
+                // Фильтруем по типу на клиенте (если API не поддерживает фильтрацию)
+                if (type && notifications.length > 0) {
+                    notifications = notifications.filter(notif => notif.type === type);
+                }
+                
+                return {
+                    notifications: notifications,
+                    pagination: pagination
+                };
+            } 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} notificationId - ID уведомления
+     * @returns {Promise<Object|null>} { success: true } или null при ошибке
+     */
+    async markAsRead(notificationId) {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+
+        try {
+            const readUrl = `${this.client.baseUrl}/api/notifications/${notificationId}/read`;
+            const response = await this.axios.post(readUrl);
+
+            if (response.status === 200 || response.status === 204) {
+                // Структура ответа: { success: true }
+                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;
+        }
+    }
+
+    /**
+     * Получает количество непрочитанных уведомлений
+     * 
+     * @returns {Promise<number|null>} Количество уведомлений или null при ошибке
+     */
+    async getUnreadCount() {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return null;
+        }
+
+        try {
+            const countUrl = `${this.client.baseUrl}/api/notifications/count`;
+            const response = await this.axios.get(countUrl);
+
+            if (response.status === 200) {
+                const data = response.data;
+                // Структура: { count: number }
+                return data.count || 0;
+            } 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;
+        }
+    }
+
+    /**
+     * Отмечает все уведомления как прочитанные
+     * 
+     * @returns {Promise<boolean>} True если успешно
+     */
+    async markAllAsRead() {
+        if (!await this.client.auth.checkAuth()) {
+            console.error('Ошибка: необходимо войти в аккаунт');
+            return false;
+        }
+
+        try {
+            // Нужно найти реальный endpoint, пока используем предположительный
+            const readAllUrl = `${this.client.baseUrl}/api/notifications/read-all`;
+            const response = await this.axios.post(readAllUrl);
+
+            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);
+                // Если 404 - значит endpoint неправильный, нужно найти реальный
+                if (error.response.status === 404) {
+                    console.error('💡 Endpoint не найден. Найди реальный URL в DevTools');
+                }
+            }
+            return false;
+        }
+    }
+    
+    // ========== USER-FRIENDLY МЕТОДЫ ==========
+    
+    /**
+     * Проверяет, есть ли непрочитанные уведомления (удобный метод)
+     * 
+     * @returns {Promise<boolean>} True если есть непрочитанные
+     */
+    async hasUnreadNotifications() {
+        const count = await this.getUnreadCount();
+        return (count || 0) > 0;
+    }
+    
+    /**
+     * Получает только непрочитанные уведомления (удобный метод)
+     * 
+     * @param {number} limit - Количество уведомлений
+     * @param {string|null} cursor - Курсор для пагинации
+     * @returns {Promise<Object|null>} { notifications: [], pagination: {} } или null
+     */
+    async getUnreadNotifications(limit = 20, cursor = null) {
+        const all = await this.getNotifications(limit, cursor);
+        if (!all) return null;
+        
+        // Фильтруем только непрочитанные
+        const unread = all.notifications.filter(n => !n.read);
+        return {
+            notifications: unread,
+            pagination: all.pagination
+        };
+    }
+
+}