Update routers/instagram.py

routers/instagram.py

@@ -1,346 +1,45 @@
-import os
 import httpx
-import socket
-from typing import Dict, Optional, Tuple
 from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
 
 router = APIRouter()
 
-# 📱 Instagram API Config
-INSTAGRAM_API_BASE = "https://graph.instagram.com"  # Removido v23.0 para testar
-INSTAGRAM_PAGE_ID = "17841464166934843"  # Seu Page ID
-INSTAGRAM_TOKEN = os.getenv("INSTAGRAM_ACCESS_TOKEN")
-
-if not INSTAGRAM_TOKEN:
-    raise ValueError("❌ INSTAGRAM_ACCESS_TOKEN não foi definido nas variáveis de ambiente!")
-
-# 📝 Modelos de dados
-class InstagramPost(BaseModel):
-    image_url: str
-    caption: Optional[str] = None
-
-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
-
-# 🔍 Função para testar conectividade
-async def test_connectivity():
-    """Testa a conectividade básica com a API do Instagram"""
-    try:
-        # Teste 1: Resolução DNS
-        print("🔍 Testando resolução DNS...")
-        socket.gethostbyname("graph.instagram.com")
-        print("✅ DNS resolvido com sucesso")
-        
-        # Teste 2: Conexão HTTP
-        print("🔍 Testando conectividade HTTP...")
-        async with httpx.AsyncClient(timeout=10.0) as client:
-            response = await client.get("https://graph.instagram.com")
-            print(f"✅ Conectividade OK - Status: {response.status_code}")
-            
-    except socket.gaierror as e:
-        print(f"❌ Erro de DNS: {e}")
-        raise HTTPException(status_code=502, detail=f"Erro de resolução DNS: {e}")
-    except Exception as e:
-        print(f"❌ Erro de conectividade: {e}")
-        raise HTTPException(status_code=502, detail=f"Erro de conectividade: {e}")
-
-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
-
-def format_text_for_instagram(text: str) -> Tuple[str, Optional[str]]:
+@router.get("/get")
+async def test_instagram_api():
     """
-    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)
+    Executa exatamente o mesmo cURL que funcionou no playground
     """
-    if not text:
-        return "", None
-    
-    # 🧹 Limpa as tags HTML
-    text = clean_html_tags(text)
-    
-    max_length = 2200
-    suffix = '\n\n💬 Continua nos comentários!'
-    
-    if len(text) <= max_length:
-        return text, None
-    
-    cutoff_length = max_length - len(suffix)
-    if cutoff_length <= 0:
-        return suffix.strip(), text
     
-    trimmed = text[:cutoff_length]
+    # URL exata do cURL que funcionou
+    url = "https://graph.instagram.com/17841464166934843/media"
     
-    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
+    # Parâmetros exatos do cURL
+    params = {
+        "domain": "INSTAGRAM",
+        "image_url": "https://static01.nyt.com/images/2025/08/06/multimedia/06xp-mack-vkjp/06xp-mack-vkjp-mobileMasterAt3x.jpg",
+        "access_token": "IGAAPf2LpaWcxBZAE1xTUdBeGFFTWFZAVTFMOHdBc21pTlJULXVaWVBXZAUNfZAUFKS1hMeENUV1FFRmpURjUxdnhZAeDN1cmVJLVFJeTZAuclFKVVRWNmltTHV1TE9pdXVWTVpzbFNqbGxVb1U1X3d0a3ozNDJWeFhvbHlZAckR0OXRlawZDZD"
+    }
     
-    # 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:
-        comment_url = f"{INSTAGRAM_API_BASE}/{post_id}/comments"
-        headers = {
-            "Content-Type": "application/json"
-        }
-        
-        comment_payload = {
-            "message": comment_text,
-            "access_token": INSTAGRAM_TOKEN
-        }
-        
-        print(f"💬 Postando comentário no post {post_id}")
-        comment_response = await client.post(
-            comment_url,
-            headers=headers,
-            json=comment_payload
-        )
-        
-        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
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            print(f"🚀 Fazendo POST para: {url}")
+            print(f"📋 Parâmetros: {params}")
             
-    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
-    """
-    
-    # 🔍 Testa conectividade antes de prosseguir
-    await test_connectivity()
-    
-    # Configuração do cliente HTTP com mais opções
-    client_config = httpx.AsyncClient(
-        timeout=httpx.Timeout(30.0, connect=10.0),
-        follow_redirects=True,
-        verify=True,  # Verifica certificados SSL
-        limits=httpx.Limits(max_connections=10, max_keepalive_connections=5)
-    )
-    
-    async with client_config 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
-            # Usando parâmetros de query ao invés de JSON body (como no curl que funcionou)
-            media_params = {
-                "image_url": post.image_url,
-                "access_token": INSTAGRAM_TOKEN
-            }
-            
-            # Adiciona caption processada se fornecida
-            if main_caption:
-                media_params["caption"] = main_caption
-            
-            media_url = f"{INSTAGRAM_API_BASE}/{INSTAGRAM_PAGE_ID}/media"
-            
-            print(f"📤 Criando media container para: {post.image_url}")
-            print(f"🔗 URL: {media_url}")
-            if remaining_text:
-                print(f"✂️ Texto cortado - será postado comentário com {len(remaining_text)} caracteres")
-            
-            # Usando POST com parâmetros de query (igual ao curl)
-            media_response = await client.post(
-                media_url,
-                params=media_params  # Mudança aqui: usando params ao invés de json
-            )
-            
-            print(f"📊 Status da resposta: {media_response.status_code}")
-            print(f"📊 Headers da resposta: {dict(media_response.headers)}")
-            
-            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}"
-                )
+            # Faz a requisição POST exatamente como o cURL
+            response = await client.post(url, params=params)
             
-            media_data = media_response.json()
-            media_id = media_data.get("id")
+            print(f"📊 Status Code: {response.status_code}")
+            print(f"📄 Response: {response.text}")
             
-            if not media_id:
-                raise HTTPException(
-                    status_code=500, 
-                    detail="ID do media container não retornado"
-                )
-            
-            print(f"✅ Media container criado com ID: {media_id}")
-            
-            # 🎯 ETAPA 2: Publicar o post
-            publish_params = {
-                "creation_id": media_id,
-                "access_token": INSTAGRAM_TOKEN
+            # Retorna a resposta completa
+            return {
+                "status_code": response.status_code,
+                "response_text": response.text,
+                "success": response.status_code == 200
             }
             
-            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,
-                params=publish_params  # Usando params também aqui
-            )
-            
-            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_params = {
-                        "fields": "permalink",
-                        "access_token": INSTAGRAM_TOKEN
-                    }
-                    post_details_url = f"{INSTAGRAM_API_BASE}/{post_id}"
-                    details_response = await client.get(post_details_url, params=post_details_params)
-                    
-                    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)}"
-            )
-
-# 🔍 Endpoint para testar conectividade
-@router.get("/test-connection")
-async def test_connection():
-    """Endpoint para testar a conectividade com a API do Instagram"""
-    try:
-        await test_connectivity()
-        return {"status": "success", "message": "Conectividade OK"}
-    except HTTPException as e:
-        raise e
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Erro no teste: {str(e)}")
+        print(f"❌ Erro: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Erro: {str(e)}"
+        )