Update func_facebook.py

func_facebook.py

@@ -1,126 +1,126 @@
-# func_facebook.py
-
 import facebook
 import requests
-from func_ai import analyze_sentiment, classify_comment, retrieve_from_vdb
-from datetime import datetime
+from func_ai import analyze_sentiment
 
 GRAPH_API_URL = 'https://graph.facebook.com/v20.0'
 
-def log_message(message):
-    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-    print(f"[{timestamp}] {message}")
+def hide_negative_comments(token):
+    def init_facebook_client(token):
+        print("Инициализация клиента Facebook.")
+        return facebook.GraphAPI(access_token=token)
+
+    def get_facebook_posts():
+        print("Получение постов.")
+        params = {
+            'include_inline_create': 'true'
+        }
+        graph = init_facebook_client(token)
+        
+        user_posts_data = graph.get_object(id='me/posts', fields='id,message,created_time')
+        user_posts = user_posts_data.get('data', [])
+        print(f"Найдено {len(user_posts)} пользовательских постов.")
+    
+        ads_posts_data = graph.get_object('me/ads_posts', **params)
+        ads_posts = ads_posts_data.get('data', [])
+        print(f"Найдено {len(ads_posts)} рекламных постов.")
+        
+        all_posts = user_posts + ads_posts
+        print(f"Всего постов: {len(all_posts)}.")
+        
+        return all_posts
+
+    def get_comments_for_post(post_id):
+        print(f"Получение комментариев для поста {post_id}.")
+        graph = init_facebook_client(token)
+        comments = []
+        url = f'{post_id}/comments'
+        params = {'fields': 'id,message,is_hidden'}
+        while True:
+            comments_data = graph.get_object(id=url, **params)
+            visible_comments = [comment for comment in comments_data.get('data', []) if not comment.get('is_hidden', False)]
+            comments.extend(visible_comments)
+            print(f"Найдено {len(visible_comments)} видимых комментариев для поста {post_id}.")
+            if 'paging' in comments_data and 'next' in comments_data['paging']:
+                url = comments_data['paging']['next']
+                params = {}
+            else:
+                break
+        return comments
+
+    def filter_comments(comments, sentiments):
+        print("Фильтрация негативных комментариев.")
+        negative_comments = []
+        for comment, sentiment in zip(comments, sentiments):
+            if sentiment['label'].lower() == 'negative':
+                print(f"Негативный комментарий найден: {comment['message']}")
+                negative_comments.append(comment)
+        return negative_comments
+
+    def hide_comment(comment_id):
+        print(f"Скрытие комментария {comment_id}.")
+        graph = init_facebook_client(token)
+        try:
+            graph.request(f'{comment_id}', post_args={'is_hidden': True}, method='POST')
+            return True
+        except facebook.GraphAPIError as e:
+            print(f"Ошибка при скрытии комментария {comment_id}: {e}")
+            return False
+
+    posts = get_facebook_posts()
+    if not posts:
+        print("Нет постов для обработки.")
+        return []
+
+    hidden_comments_per_post = []
+    for post in posts:
+        post_id = post['id']
+        post_message = post.get('message', '')
+        comments = get_comments_for_post(post_id)
+        if not comments:
+            print(f"Нет комментариев для поста {post_id}.")
+            continue
+
+        comments_text = [comment['message'] for comment in comments]
+        sentiments = analyze_sentiment(comments_text)
+        negative_comments = filter_comments(comments, sentiments)
+
+        hidden_comments = []
+        for comment in negative_comments:
+            if hide_comment(comment['id']):
+                hidden_comments.append({
+                    'id': comment['id'],
+                    'message': comment['message']
+                })
+
+        if hidden_comments:
+            hidden_comments_per_post.append({
+                'post_id': post_id,
+                'post_message': post_message,
+                'hidden_comments': hidden_comments
+            })
+
+    return hidden_comments_per_post
 
-def init_facebook_client(token):
-    log_message("Инициализация клиента Facebook.")
-    return facebook.GraphAPI(access_token=token)
 
 def get_page_id(page_access_token):
-    log_message("Получение ID страницы.")
+    print("Получение ID страницы.")
     url = f"{GRAPH_API_URL}/me"
     params = {
         "access_token": page_access_token,
-        "fields": "id,name,accounts"  # 'accounts' доступно только для User Access Token
+        "fields": "id,name"
     }
     response = requests.get(url, params=params)
     data = response.json()
     if 'error' in data:
-        log_message(f"Ошибка при получении ID страницы: {data['error']}")
+        print(f"Ошибка при получении ID страницы: {data['error']}")
         return None
-    
-    # Проверяем, существует ли поле 'accounts'
-    if 'accounts' in data:
-        accounts = data.get("accounts", {}).get("data", [])
-        if not accounts:
-            log_message("Нет доступных страниц для управления.")
-            return None
-        # Предполагаем, что первая страница является целевой; при необходимости измените логику
-        page_id = accounts[0].get("id")
-        log_message(f"Выбрана страница с ID: {page_id}")
-        return page_id
-    else:
-        # Если 'accounts' нет, предполагаем, что токен Page Access Token, и 'me' уже соответствует странице
-        page_id = data.get("id")
-        log_message(f"Используется Page Access Token. ID страницы: {page_id}")
-        return page_id
+    return data.get("id")
 
-def get_facebook_posts(token):
-    log_message("Получение постов.")
-    params = {
-        'include_inline_create': 'true'
-    }
-    graph = init_facebook_client(token)
-    
-    user_posts_data = graph.get_object(id='me/posts', fields='id,message,created_time')
-    user_posts = user_posts_data.get('data', [])
-    log_message(f"Найдено {len(user_posts)} пользовательских постов.")
-
-    try:
-        ads_posts_data = graph.get_object('me/ads_posts', **params)
-        ads_posts = ads_posts_data.get('data', [])
-        log_message(f"Найдено {len(ads_posts)} рекламных постов.")
-    except facebook.GraphAPIError as e:
-        log_message(f"Ошибка при получении рекламных постов: {e}")
-        ads_posts = []
-    
-    all_posts = user_posts + ads_posts
-    log_message(f"Всего постов: {len(all_posts)}.")
-    
-    return all_posts
-
-def get_comments_for_post(post_id, token):
-    log_message(f"Получение комментариев для поста {post_id}.")
-    graph = init_facebook_client(token)
-    comments = []
-    url = f'{post_id}/comments'
-    params = {'fields': 'id,message,is_hidden'}
-    while True:
-        try:
-            comments_data = graph.get_object(id=url, **params)
-        except facebook.GraphAPIError as e:
-            log_message(f"Ошибка при получении комментариев: {e}")
-            break
-        visible_comments = [comment for comment in comments_data.get('data', []) if not comment.get('is_hidden', False)]
-        comments.extend(visible_comments)
-        log_message(f"Найдено {len(visible_comments)} видимых комментариев для поста {post_id}.")
-        if 'paging' in comments_data and 'next' in comments_data['paging']:
-            url = comments_data['paging']['next']
-            params = {}
-        else:
-            break
-    return comments
-
-def has_page_replied(comment_id, page_id, page_access_token):
-    log_message(f"Проверка ответа на комментарий {comment_id}.")
-    url = f"{GRAPH_API_URL}/{comment_id}/comments"
-    params = {
-        "access_token": page_access_token,
-        "fields": "from{id,name}",
-    }
-    while True:
-        response = requests.get(url, params=params)
-        data = response.json()
-        if 'error' in data:
-            log_message(f"Ошибка при получении ответов на комментарий {comment_id}: {data['error']}")
-            return False
-        for reply in data.get("data", []):
-            from_id = reply.get('from', {}).get('id')
-            from_name = reply.get('from', {}).get('name')
-            log_message(f"Найден ответ от пользователя ID: {from_id}, Name: {from_name}")
-            if from_id == page_id:
-                log_message(f"Страница {page_id} уже ответила на комментарий {comment_id}.")
-                return True
-        if 'paging' in data and 'next' in data['paging']:
-            url = data['paging']['next']
-            params = {}
-        else:
-            break
-    return False
 
 def get_posts(page_id, page_access_token):
-    log_message(f"Получение постов для страницы {page_id}.")
+    print(f"Получение постов для страницы {page_id}.")
     url = f"{GRAPH_API_URL}/{page_id}/posts"
-    url_ads = f"{GRAPH_API_URL}/{page_id}/ads_posts"
+    url_ads = f"{GRAPH_API_URL}/{page_id}/ads_posts?include_inline_create=true"
     params = {
         "access_token": page_access_token,
         "fields": "id,message"
@@ -133,22 +133,21 @@ def get_posts(page_id, page_access_token):
         data = response.json()
 
         if 'error' in data:
-            log_message(f"Ошибка при получении постов: {data['error']}")
+            print(f"Ошибка при получении постов: {data['error']}")
             break
         
         posts.extend(data.get("data", []))
-        log_message(f"Получено {len(data.get('data', []))} постов.")
-        
-        # Получение рекламных постов
+        print(f"Получено {len(data.get('data', []))} постов.")
+
         response_ads = requests.get(url_ads, params={"access_token": page_access_token, "fields": "id,message"})
         data_ads = response_ads.json()
 
         if 'error' in data_ads:
-            log_message(f"Ошибка при получении рекламных постов: {data_ads['error']}")
+            print(f"Ошибка при получении рекламных постов: {data_ads['error']}")
             break
         
         posts.extend(data_ads.get("data", []))
-        log_message(f"Получено {len(data_ads.get('data', []))} рекламных постов.")
+        print(f"Получено {len(data_ads.get('data', []))} рекламных постов.")
         
         if 'paging' in data and 'next' in data['paging']:
             url = data['paging']['next']
@@ -158,8 +157,9 @@ def get_posts(page_id, page_access_token):
 
     return posts
 
+
 def get_comments(post_id, page_access_token):
-    log_message(f"Получение комментариев для поста {post_id}.")
+    print(f"Получение комментариев для поста {post_id}.")
     url = f"{GRAPH_API_URL}/{post_id}/comments"
     params = {
         "access_token": page_access_token,
@@ -170,10 +170,10 @@ def get_comments(post_id, page_access_token):
         response = requests.get(url, params=params)
         data = response.json()
         if 'error' in data:
-            log_message(f"Ошибка при получении комментариев к посту {post_id}: {data['error']}")
+            print(f"Ошибка при получении комментариев к посту {post_id}: {data['error']}")
             break
         comments.extend(data.get("data", []))
-        log_message(f"Найдено {len(data.get('data', []))} комментариев.")
+        print(f"Найдено {len(data.get('data', []))} комментариев.")
         if 'paging' in data and 'next' in data['paging']:
             url = data['paging']['next']
             params = {}
@@ -181,19 +181,45 @@ def get_comments(post_id, page_access_token):
             break
     return comments
 
+
+def has_page_replied(comment_id, page_id, page_access_token):
+    print(f"Проверка ответа на комментарий {comment_id}.")
+    url = f"{GRAPH_API_URL}/{comment_id}/comments"
+    params = {
+        "access_token": page_access_token,
+        "fields": "from{id}",
+    }
+    while True:
+        response = requests.get(url, params=params)
+        data = response.json()
+        if 'error' in data:
+            print(f"Ошибка при получении ответов на комментарий {comment_id}: {data['error']}")
+            return False
+        for reply in data.get("data", []):
+            if reply['from']['id'] == page_id:
+                print(f"Страница {page_id} уже ответила на комментарий {comment_id}.")
+                return True
+        if 'paging' in data and 'next' in data['paging']:
+            url = data['paging']['next']
+            params = {}
+        else:
+            break
+    return False
+
+
 def get_unanswered_comments(page_access_token):
     page_id = get_page_id(page_access_token)
     if not page_id:
         return []
 
-    log_message(f"ID Страницы: {page_id}")
+    print(f"ID Страницы: {page_id}")
     posts = get_posts(page_id, page_access_token)
     posts_with_unanswered_comments = []
 
     for post in posts:
         post_id = post['id']
         post_message = post.get('message', '')
-        log_message(f"Обработка поста: {post_id}")
+        print(f"Обработка поста: {post_id}")
         comments = get_comments(post_id, page_access_token)
 
         unanswered_comments = []
@@ -202,7 +228,7 @@ def get_unanswered_comments(page_access_token):
             if comment.get('is_hidden', False):
                 continue
             comment_id = comment['id']
-            log_message(f"Проверка комментария: {comment_id}")
+            print(f"Проверка комментария: {comment_id}")
             if not has_page_replied(comment_id, page_id, page_access_token):
                 unanswered_comments.append(comment)
 
@@ -215,8 +241,9 @@ def get_unanswered_comments(page_access_token):
 
     return posts_with_unanswered_comments
 
+
 def reply_comment(comment_id, message, token):
-    log_message(f"Отправка ответа на комментарий {comment_id}.")
+    print(f"Отправка ответа на комментарий {comment_id}.")
     url = f"{GRAPH_API_URL}/{comment_id}/comments"
     params = {
         'access_token': token,
@@ -224,56 +251,8 @@ def reply_comment(comment_id, message, token):
     }
     response = requests.post(url, params=params)
     if response.status_code == 200:
-        log_message(f"Ответ успешно отправлен на комментарий {comment_id}.")
+        print(f"Ответ успешно отправлен на комментарий {comment_id}.")
         return True
     else:
-        log_message(f"Ошибка при отправке ответа: {response.text}")
-        return False
-
-def hide_negative_comments(token):
-    log_message("Начинаем процесс скрытия отрицательных комментариев.")
-    posts = get_facebook_posts(token)
-    if not posts:
-        log_message("Нет постов для обработки.")
-        return []
-
-    hidden_comments_per_post = []
-    for post in posts:
-        post_id = post['id']
-        post_message = post.get('message', '')
-        comments = get_comments_for_post(post_id, token)
-        if not comments:
-            log_message(f"Нет комментариев для поста {post_id}.")
-            continue
-
-        comments_text = [comment['message'] for comment in comments]
-        sentiments = analyze_sentiment(comments_text)
-        # Фильтруем только негативные комментарии
-        negative_comments = [comment for comment, sentiment in zip(comments, sentiments) if sentiment['label'].lower() == 'negative']
-
-        hidden_comments = []
-        for comment in negative_comments:
-            if hide_comment(comment['id'], token):
-                hidden_comments.append({
-                    'id': comment['id'],
-                    'message': comment['message']
-                })
-
-        if hidden_comments:
-            hidden_comments_per_post.append({
-                'post_id': post_id,
-                'post_message': post_message,
-                'hidden_comments': hidden_comments
-            })
-
-    return hidden_comments_per_post
-
-def hide_comment(comment_id, token):
-    log_message(f"Скрытие комментария {comment_id}.")
-    graph = init_facebook_client(token)
-    try:
-        graph.request(f'{comment_id}', post_args={'is_hidden': True}, method='POST')
-        return True
-    except facebook.GraphAPIError as e:
-        log_message(f"Ошибка при скрытии комментария {comment_id}: {e}")
-        return False
+        print(f"Ошибка при отправке ответа: {response.text}")
+        return False