Update routers/instagram.py

routers/instagram.py

@@ -1,104 +1,294 @@
 import os
-import requests
+import httpx
+from typing import Dict, Optional, Tuple
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-import socket
 
 router = APIRouter()
 
-# 📌 Instagram Graph API
-INSTAGRAM_ACCESS_TOKEN = os.getenv("INSTAGRAM_ACCESS_TOKEN")
-INSTAGRAM_USER_ID = "17841464166934843"
+# 📱 Instagram API Config
+INSTAGRAM_API_BASE = "https://graph.instagram.com/v23.0"
+INSTAGRAM_PAGE_ID = "17841464166934843"  # Seu Page ID
+INSTAGRAM_TOKEN = os.getenv("INSTAGRAM_ACCESS_TOKEN")
 
-if not INSTAGRAM_ACCESS_TOKEN:
-    raise ValueError("❌ INSTAGRAM_ACCESS_TOKEN não configurado no ambiente!")
+if not INSTAGRAM_TOKEN:
+    raise ValueError("❌ INSTAGRAM_ACCESS_TOKEN não foi definido nas variáveis de ambiente!")
 
-# 🔧 Configura DNS programaticamente
-def setup_dns():
-    """Configura DNS alternativo se necessário"""
-    try:
-        # Testa se consegue resolver
-        socket.gethostbyname('google.com')
-        return True
-    except:
-        # Se falhar, configura DNS manual
-        import dns.resolver
-        dns.resolver.default_resolver = dns.resolver.Resolver(configure=False)
-        dns.resolver.default_resolver.nameservers = ['8.8.8.8', '8.8.4.4']
-        return False
+# 📝 Modelos de dados
+class InstagramPost(BaseModel):
+    image_url: str
+    caption: Optional[str] = None
 
-# Executa setup DNS na importação
-try:
-    setup_dns()
-except:
-    pass
+class PublishResponse(BaseModel):
+    success: bool
+    media_id: Optional[str] = None
+    post_id: Optional[str] = None
+    post_url: Optional[str] = None
+    message: str
+    comment_posted: bool = False
+    comment_id: Optional[str] = None
 
-class InstagramMedia(BaseModel):
-    image_url: str
+def clean_html_tags(text: str) -> str:
+    """
+    Remove todas as tags HTML.
+    Converte <p> para quebras de linha.
+    
+    Returns:
+        str: Texto limpo sem tags HTML
+    """
+    if not text:
+        return ""
+    
+    import re
+    
+    # Converte <p> para quebras de linha
+    text = re.sub(r'<p[^>]*>(.*?)</p>', r'\1\n\n', text, flags=re.DOTALL | re.IGNORECASE)
+    
+    # Converte <br> e <br/> para quebra de linha simples
+    text = re.sub(r'<br\s*/?>', '\n', text, flags=re.IGNORECASE)
+    
+    # Remove todas as tags HTML
+    text = re.sub(r'<[^>]*>', '', text, flags=re.IGNORECASE)
+    
+    # Remove quebras de linha excessivas e espaços extras
+    text = re.sub(r'\n\s*\n\s*\n+', '\n\n', text)  # Máximo de 2 quebras consecutivas
+    text = re.sub(r'[ \t]+', ' ', text)  # Remove espaços/tabs extras
+    text = text.strip()
+    
+    return text
 
-@router.post("/instagram/container")
-async def create_instagram_container(media: InstagramMedia):
-    url = f"https://graph.instagram.com/v23.0/{INSTAGRAM_USER_ID}/media"
+def format_text_for_instagram(text: str) -> Tuple[str, Optional[str]]:
+    """
+    Formata o texto para o Instagram:
+    1. Limpa tags HTML
+    2. Corta se necessário e retorna o texto principal e o resto para comentário
+    
+    Returns:
+        Tuple[str, Optional[str]]: (texto_principal, resto_para_comentario)
+    """
+    if not text:
+        return "", None
+    
+    # 🧹 Limpa as tags HTML
+    text = clean_html_tags(text)
+    
+    max_length = 2200
+    suffix = '\n\n💬 Continua nos comentários!'
     
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {INSTAGRAM_ACCESS_TOKEN}"
-    }
+    if len(text) <= max_length:
+        return text, None
     
-    payload = {"image_url": media.image_url}
+    cutoff_length = max_length - len(suffix)
+    if cutoff_length <= 0:
+        return suffix.strip(), text
     
-    # Configurar sessão com configurações específicas para resolver DNS
-    session = requests.Session()
+    trimmed = text[:cutoff_length]
     
+    def is_inside_quotes(s: str, index: int) -> bool:
+        """Verifica se há aspas abertas não fechadas até o índice"""
+        up_to_index = s[:index + 1]
+        quote_count = up_to_index.count('"')
+        return quote_count % 2 != 0
+    
+    # Encontra o último ponto final fora de aspas
+    last_valid_dot = -1
+    for i in range(len(trimmed) - 1, -1, -1):
+        if trimmed[i] == '.' and not is_inside_quotes(trimmed, i):
+            last_valid_dot = i
+            break
+    
+    if last_valid_dot > 100:
+        main_text = trimmed[:last_valid_dot + 1]
+        remaining_text = text[last_valid_dot + 1:].strip()
+    else:
+        main_text = trimmed
+        remaining_text = text[cutoff_length:].strip()
+    
+    final_main_text = f"{main_text}{suffix}"
+    
+    return final_main_text, remaining_text if remaining_text else None
+
+async def post_comment(client: httpx.AsyncClient, post_id: str, comment_text: str) -> Optional[str]:
+    """
+    Posta um comentário no post do Instagram
+    
+    Returns:
+        Optional[str]: ID do comentário se postado com sucesso
+    """
     try:
-        # Força uso de DNS específico via requests
-        response = session.post(
-            url, 
-            headers=headers, 
-            json=payload, 
-            timeout=30.0,
-            # Configurações extras para problemas de rede
-            allow_redirects=True,
-            verify=True
-        )
+        comment_url = f"{INSTAGRAM_API_BASE}/{post_id}/comments"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {INSTAGRAM_TOKEN}"
+        }
         
-        if response.status_code != 200:
-            raise HTTPException(status_code=response.status_code, detail=response.text)
+        comment_payload = {
+            "message": comment_text
+        }
         
-        data = response.json()
-        return {"id": data.get("id")}
+        print(f"💬 Postando comentário no post {post_id}")
+        comment_response = await client.post(
+            comment_url,
+            headers=headers,
+            json=comment_payload
+        )
         
-    except requests.exceptions.ConnectionError as e:
-        if "name resolution" in str(e).lower():
-            # Tenta com IP direto como fallback
-            try:
-                ip_url = url.replace("graph.instagram.com", "31.13.24.51")
-                headers["Host"] = "graph.instagram.com"
-                
-                response = session.post(
-                    ip_url, 
-                    headers=headers, 
-                    json=payload, 
-                    timeout=30.0,
-                    verify=False  # Necessário quando usando IP
+        if comment_response.status_code == 200:
+            comment_data = comment_response.json()
+            comment_id = comment_data.get("id")
+            print(f"✅ Comentário postado com ID: {comment_id}")
+            return comment_id
+        else:
+            error_detail = comment_response.text
+            print(f"⚠️ Erro ao postar comentário: {error_detail}")
+            return None
+            
+    except Exception as e:
+        print(f"⚠️ Erro inesperado ao postar comentário: {str(e)}")
+        return None
+
+# 🚀 Endpoint principal para publicar no Instagram
+@router.post("/publish", response_model=PublishResponse)
+async def publish_instagram_post(post: InstagramPost) -> PublishResponse:
+    """
+    Publica uma imagem no Instagram em duas etapas:
+    1. Cria o media container
+    2. Publica o post
+    3. Se necessário, posta o resto do texto como comentário
+    """
+    
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        try:
+            # 📝 Processa o texto da caption
+            main_caption, remaining_text = format_text_for_instagram(post.caption) if post.caption else ("", None)
+            
+            # 🎯 ETAPA 1: Criar o media container
+            media_payload = {
+                "image_url": post.image_url
+            }
+            
+            # Adiciona caption processada se fornecida
+            if main_caption:
+                media_payload["caption"] = main_caption
+            
+            media_url = f"{INSTAGRAM_API_BASE}/{INSTAGRAM_PAGE_ID}/media"
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {INSTAGRAM_TOKEN}"
+            }
+            
+            print(f"📤 Criando media container para: {post.image_url}")
+            if remaining_text:
+                print(f"✂️ Texto cortado - será postado comentário com {len(remaining_text)} caracteres")
+            
+            media_response = await client.post(
+                media_url, 
+                headers=headers, 
+                json=media_payload
+            )
+            
+            if media_response.status_code != 200:
+                error_detail = media_response.text
+                print(f"❌ Erro ao criar media container: {error_detail}")
+                raise HTTPException(
+                    status_code=media_response.status_code, 
+                    detail=f"Erro ao criar media container: {error_detail}"
                 )
-                
-                if response.status_code != 200:
-                    raise HTTPException(status_code=response.status_code, detail=response.text)
-                
-                data = response.json()
-                return {"id": data.get("id")}
-                
-            except Exception as fallback_error:
+            
+            media_data = media_response.json()
+            media_id = media_data.get("id")
+            
+            if not media_id:
                 raise HTTPException(
                     status_code=500, 
-                    detail=f"DNS error and IP fallback failed: {fallback_error}"
+                    detail="ID do media container não retornado"
                 )
-        else:
-            raise HTTPException(status_code=500, detail=f"Connection error: {e}")
             
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Unexpected error: {e}")
-    
-    finally:
-        session.close()
+            print(f"✅ Media container criado com ID: {media_id}")
+            
+            # 🎯 ETAPA 2: Publicar o post
+            publish_payload = {
+                "creation_id": media_id
+            }
+            
+            publish_url = f"{INSTAGRAM_API_BASE}/{INSTAGRAM_PAGE_ID}/media_publish"
+            
+            print(f"📤 Publicando post com creation_id: {media_id}")
+            publish_response = await client.post(
+                publish_url, 
+                headers=headers, 
+                json=publish_payload
+            )
+            
+            if publish_response.status_code != 200:
+                error_detail = publish_response.text
+                print(f"❌ Erro ao publicar post: {error_detail}")
+                raise HTTPException(
+                    status_code=publish_response.status_code, 
+                    detail=f"Erro ao publicar post: {error_detail}"
+                )
+            
+            publish_data = publish_response.json()
+            post_id = publish_data.get("id")
+            
+            # 🔗 ETAPA 3: Obter detalhes do post para construir URL
+            post_url = None
+            if post_id:
+                try:
+                    # Query para obter o permalink do post
+                    post_details_url = f"{INSTAGRAM_API_BASE}/{post_id}?fields=permalink"
+                    details_response = await client.get(post_details_url, headers=headers)
+                    
+                    if details_response.status_code == 200:
+                        details_data = details_response.json()
+                        post_url = details_data.get("permalink")
+                        print(f"🔗 Link do post: {post_url}")
+                    else:
+                        print(f"⚠️ Não foi possível obter o link do post: {details_response.text}")
+                except Exception as e:
+                    print(f"⚠️ Erro ao obter link do post: {str(e)}")
+            
+            # 💬 ETAPA 4: Postar comentário com o resto do texto (se necessário)
+            comment_posted = False
+            comment_id = None
+            
+            if remaining_text and post_id:
+                comment_id = await post_comment(client, post_id, remaining_text)
+                comment_posted = comment_id is not None
+            
+            success_message = "Post publicado com sucesso no Instagram!"
+            if comment_posted:
+                success_message += " Texto adicional postado como comentário."
+            elif remaining_text and not comment_posted:
+                success_message += " ATENÇÃO: Não foi possível postar o comentário com o resto do texto."
+            
+            print(f"🎉 {success_message} Post ID: {post_id}")
+            
+            return PublishResponse(
+                success=True,
+                media_id=media_id,
+                post_id=post_id,
+                post_url=post_url,
+                message=success_message,
+                comment_posted=comment_posted,
+                comment_id=comment_id
+            )
+            
+        except httpx.TimeoutException:
+            print("⏰ Timeout na requisição para Instagram API")
+            raise HTTPException(
+                status_code=408, 
+                detail="Timeout na comunicação com a API do Instagram"
+            )
+        except httpx.RequestError as e:
+            print(f"🌐 Erro de conexão: {str(e)}")
+            raise HTTPException(
+                status_code=502, 
+                detail=f"Erro de conexão: {str(e)}"
+            )
+        except Exception as e:
+            print(f"💥 Erro inesperado: {str(e)}")
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Erro interno do servidor: {str(e)}"
+            )