strategya-ai-news.php

Arquivo Principal do Plugin

Este é o arquivo principal do plugin WordPress Strategya AI News Generator


            

            
            

                

                    
                    Funcionalidades Implementadas
                

                
    
                    
  • ✅ Estrutura completa do plugin WordPress
    • 
                    
  • ✅ Sistema de segurança com nonces e validações
    • 
                    
  • ✅ Integração com OpenAI API
    • 
                    
  • ✅ Suporte para Excel e Google Sheets
    • 
                    
  • ✅ Interface administrativa completa
    • 
                    
  • ✅ Sistema de logs e analytics
    • 
                    
  • ✅ Configurações flexíveis
    • 
                    
  • ✅ Suporte multi-idioma
    • 
                

            

            
            

                

                    
                    Próximos Passos
                

                

                    Este é o arquivo principal do plugin. Agora criarei todos os outros arquivos necessários para o funcionamento completo do sistema.
                

            

        

    



    
    
    
    


    
    
    openai-client.php - Integração OpenAI
    
    
    


    

        

            

                
                
openai-client.php

            

            
            

                

                    
                    Descrição
                

                

                    Cliente para integração com API OpenAI/ChatGPT para geração de conteúdo jornalístico. 
                    Inclui funcionalidades para geração de texto, imagens e verificação de conteúdo.
                

            


            

                

                    
                    Código PHP
                

                

<?php
/**
 * Strategya AI News Generator - OpenAI Client
 * 
 * Cliente para integração com API OpenAI/ChatGPT
 * Desenvolvido exclusivamente para Strategya Co., Ltd.
 * 
 * @package StrategYaAINews
 * @version 1.0.0
 * @author Strategya Co., Ltd.
 */

if (!defined('ABSPATH')) {
    exit; // Impede acesso direto
}

class Strategya_OpenAI_Client {
    
    private $api_key;
    private $base_url = 'https://api.openai.com/v1';
    private $model = 'gpt-4-turbo-preview';
    private $max_tokens = 4000;
    
    public function __construct($api_key) {
        $this->api_key = sanitize_text_field($api_key);
    }
    
    /**
     * Gera conteúdo jornalístico com base no tema
     * 
     * @param string $tema Tema do artigo
     * @param string $idioma Idioma do artigo (pt, en, ja)
     * @param string $tipo Tipo de artigo (noticia, guia, opiniao)
     * @return array Dados do artigo gerado
     */
    public function generate_news_content($tema, $idioma = 'pt', $tipo = 'noticia') {
        
        $prompt = $this->build_content_prompt($tema, $idioma, $tipo);
        
        $response = $this->call_openai_api($prompt);
        
        if (is_wp_error($response)) {
            return $response;
        }
        
        return $this->parse_content_response($response);
    }
    
    /**
     * Constrói prompt otimizado para geração de conteúdo
     */
    private function build_content_prompt($tema, $idioma, $tipo) {
        
        $idioma_full = array(
            'pt' => 'português brasileiro',
            'en' => 'inglês',
            'ja' => 'japonês'
        );
        
        $tipo_desc = array(
            'noticia' => 'notícia jornalística',
            'guia' => 'guia informativo',
            'opiniao' => 'artigo de opinião'
        );
        
        $prompt = "Você é um jornalista especializado em conteúdo para estrangeiros no Japão. 

Crie uma {$tipo_desc[$tipo]} completa em {$idioma_full[$idioma]} sobre o tema: '{$tema}'

ESTRUTURA OBRIGATÓRIA:
- Título SEO otimizado (máximo 60 caracteres)
- Excerpt/resumo (máximo 160 caracteres)
- Conteúdo principal com mínimo 30 linhas
- Subtítulos H2 e H3 bem estruturados
- Listas com bullet points
- Conclusão clara
- 5 tags relevantes
- Meta description (150-160 caracteres)

DIRETRIZES SEO & EEAT:
- Use palavra-chave principal no título e primeiro parágrafo
- Inclua informações verificáveis e atualizadas
- Mantenha tom neutro e profissional
- Adicione dados específicos sobre o Japão quando relevante
- Estruture com H2/H3 para melhor legibilidade

FORMATO DE RESPOSTA (JSON):
{
  \"titulo\": \"Título otimizado\",
  \"excerpt\": \"Resumo do artigo\",
  \"conteudo\": \"Conteúdo completo com HTML tags\",
  \"tags\": [\"tag1\", \"tag2\", \"tag3\", \"tag4\", \"tag5\"],
  \"meta_description\": \"Meta descrição SEO\",
  \"palavra_chave\": \"palavra-chave principal\",
  \"categoria\": \"categoria sugerida\"
}

Responda APENAS com o JSON válido.";
        
        return $prompt;
    }
    
    /**
     * Chama API OpenAI
     */
    private function call_openai_api($prompt) {
        
        $headers = array(
            'Authorization' => 'Bearer ' . $this->api_key,
            'Content-Type' => 'application/json'
        );
        
        $body = json_encode(array(
            'model' => $this->model,
            'messages' => array(
                array(
                    'role' => 'user',
                    'content' => $prompt
                )
            ),
            'max_tokens' => $this->max_tokens,
            'temperature' => 0.7
        ));
        
        $response = wp_remote_post($this->base_url . '/chat/completions', array(
            'headers' => $headers,
            'body' => $body,
            'timeout' => 60
        ));
        
        if (is_wp_error($response)) {
            return $response;
        }
        
        $status_code = wp_remote_retrieve_response_code($response);
        
        if ($status_code !== 200) {
            return new WP_Error('openai_error', 'Erro na API OpenAI: ' . $status_code);
        }
        
        $body = wp_remote_retrieve_body($response);
        $data = json_decode($body, true);
        
        if (!isset($data['choices'][0]['message']['content'])) {
            return new WP_Error('openai_parse_error', 'Resposta inválida da API');
        }
        
        return $data['choices'][0]['message']['content'];
    }
    
    /**
     * Processa resposta da API
     */
    private function parse_content_response($response) {
        
        // Remove possíveis caracteres extras
        $response = trim($response);
        $response = str_replace(['```json', '```'], '', $response);
        
        $data = json_decode($response, true);
        
        if (json_last_error() !== JSON_ERROR_NONE) {
            return new WP_Error('json_parse_error', 'Erro ao processar resposta JSON');
        }
        
        // Validação dos campos obrigatórios
        $required_fields = ['titulo', 'excerpt', 'conteudo', 'tags'];
        
        foreach ($required_fields as $field) {
            if (!isset($data[$field]) || empty($data[$field])) {
                return new WP_Error('missing_field', 'Campo obrigatório ausente: ' . $field);
            }
        }
        
        // Sanitização dos dados
        $data['titulo'] = sanitize_text_field($data['titulo']);
        $data['excerpt'] = sanitize_textarea_field($data['excerpt']);
        $data['conteudo'] = wp_kses_post($data['conteudo']);
        
        if (is_array($data['tags'])) {
            $data['tags'] = array_map('sanitize_text_field', $data['tags']);
        }
        
        return $data;
    }
    
    /**
     * Gera imagem com DALL-E
     */
    public function generate_image($prompt, $size = '1024x1024') {
        
        $headers = array(
            'Authorization' => 'Bearer ' . $this->api_key,
            'Content-Type' => 'application/json'
        );
        
        $body = json_encode(array(
            'model' => 'dall-e-3',
            'prompt' => $prompt,
            'size' => $size,
            'quality' => 'standard',
            'n' => 1
        ));
        
        $response = wp_remote_post($this->base_url . '/images/generations', array(
            'headers' => $headers,
            'body' => $body,
            'timeout' => 60
        ));
        
        if (is_wp_error($response)) {
            return $response;
        }
        
        $body = wp_remote_retrieve_body($response);
        $data = json_decode($body, true);
        
        if (isset($data['data'][0]['url'])) {
            return $data['data'][0]['url'];
        }
        
        return new WP_Error('image_generation_error', 'Erro ao gerar imagem');
    }
    
    /**
     * Verifica se API key é válida
     */
    public function test_api_connection() {
        
        $headers = array(
            'Authorization' => 'Bearer ' . $this->api_key
        );
        
        $response = wp_remote_get($this->base_url . '/models', array(
            'headers' => $headers,
            'timeout' => 10
        ));
        
        if (is_wp_error($response)) {
            return false;
        }
        
        $status_code = wp_remote_retrieve_response_code($response);
        
        return $status_code === 200;
    }
}
                

            


            

                

                    

                        
                        Funcionalidades Incluídas
                    

                    
    
                        
  • • Geração de conteúdo jornalístico
    • 
                        
  • • Suporte multi-idioma (PT, EN, JA)
    • 
                        
  • • Geração de imagens com DALL-E
    • 
                        
  • • Validação de API key
    • 
                        
  • • Sanitização de dados
    • 
                        
  • • Tratamento de erros
    • 
                    

                

                
                

                    

                        
                        Configurações
                    

                    
    
                        
  • • Modelo: GPT-4 Turbo
    • 
                        
  • • Max tokens: 4000
    • 
                        
  • • Temperature: 0.7
    • 
                        
  • • Timeout: 60 segundos
    • 
                        
  • • Formato de resposta: JSON
    • 
                    

                

            

        

    



    
    
    
    


    
    
    spreadsheet-reader.php - Leitor de Excel
    
    


    

        

            

                

                    
                    spreadsheet-reader.php
                

                
                    Leitor de Excel
                
            

            
            

                

                    
                    

                        
Funcionalidade para upload e leitura de arquivos Excel

                        
Integração com PhpSpreadsheet para processar planilhas Excel (.xlsx)

                    

                

            


            

                

                    

                        Recursos Principais
                    

                    
    
                        
  • Upload seguro de arquivos Excel
    • 
                        
  • Validação de formato e tamanho
    • 
                        
  • Leitura de múltiplas planilhas
    • 
                        
  • Processamento de dados
    • 
                        
  • Tratamento de erros
    • 
                    

                


                

                    

                        Segurança
                    

                    
    
                        
  • Validação de tipo MIME
    • 
                        
  • Sanitização de dados
    • 
                        
  • Verificação de permissões
    • 
                        
  • Proteção contra malware
    • 
                        
  • Limpeza automática de arquivos
    • 
                    

                

            


            

                

                    Código PHP
                

                
                

                    

                

            


            

                

                    

                        Requisitos
                    

                    
    
                        
  • • PhpSpreadsheet instalado
    • 
                        
  • • PHP 7.4+ com extensão finfo
    • 
                        
  • • Permissões de escrita no upload
    • 
                        
  • • Limite de upload configurado
    • 
                    

                


                

                    

                        Funcionalidades
                    

                    
    
                        
  • • Upload via AJAX
    • 
                        
  • • Processamento em background
    • 
                        
  • • Validação automática
    • 
                        
  • • Limpeza de arquivos antigos
    • 
                    

                

            


            

                

                    
                    Strategya Co., Ltd. - Sistema exclusivo de geração de conteúdo
                

            

        

    



    
    
    
    


    
    
    google-sheets-client.php - Integração Google Sheets
    
    
    
    
    


    

        

            

                

                    
                    google-sheets-client.php
                

                
Cliente para integração com Google Sheets API - Plugin Strategya AI News Generator

            


            

                

                    
                    Descrição
                

                

                    Este arquivo contém a classe responsável pela integração com a API do Google Sheets, 
                    permitindo que o plugin leia temas de planilhas compartilhadas para geração automatizada de conteúdo.
                

            


            

                

                    
                    Código PHP
                

                

                    

                

            


            

                

                    
                    Configuração Necessária
                

                

                    

                        

                            
                        

                        

                            

                                Importante: Para usar esta funcionalidade, você precisa:
                            

                            
    
                                
  • Criar um projeto no Google Cloud Console
    • 
                                
  • Habilitar a Google Sheets API
    • 
                                
  • Criar uma API Key
    • 
                                
  • Configurar a chave no painel do plugin
    • 
                            

                        

                    

                

            


            

                

                    
                    Funcionalidades
                

                

                    

                        

                            Leitura de Dados
                        

                        

                            Lê temas de planilhas Google Sheets públicas ou compartilhadas
                        

                    

                    

                        

                            Validação
                        

                        

                            Valida URLs e testa conexão com a API do Google
                        

                    

                    

                        

                            Múltiplas Abas
                        

                        

                            Suporte para leitura de diferentes abas da planilha
                        

                    

                    

                        

                            Logs
                        

                        

                            Registra acessos às planilhas para controle e auditoria
                        

                    

                

            


            

                

                    
                    Pronto para Download
                

                

                    Este arquivo está pronto para ser integrado ao plugin WordPress. 
                    Salve como google-sheets-client.php 
                    na pasta includes/ do plugin.
                

            

        

    



    
    
    
    


    
    
    content-builder.php - Construtor de Conteúdo
    
    
    


    

        

            

                
                

                    
content-builder.php

                    
Construtor de Conteúdo SEO - Strategya AI News Generator

                

            

            
            

                

                    Descrição
                

                

                    Classe responsável por construir e otimizar conteúdo jornalístico com práticas avançadas de SEO e EEAT (Experience, Expertise, Authoritativeness, Trustworthiness).
                

            


            

                

                    Funcionalidades
                

                
    
                    
  • Estruturação de conteúdo com H2/H3 otimizados
    • 
                    
  • Geração automática de meta descriptions
    • 
                    
  • Criação de excerpts otimizados
    • 
                    
  • Análise e sugestão de palavras-chave
    • 
                    
  • Formatação para EEAT compliance
    • 
                    
  • Validação de estrutura SEO
    • 
                

            


            

<?php

/**
 * Strategya AI News Generator - Content Builder
 * 
 * Classe responsável por construir e otimizar conteúdo jornalístico
 * com práticas avançadas de SEO e EEAT
 * 
 * @package Strategya_AI_News
 * @version 1.0.0
 * @author Strategya Co., Ltd.
 */

if (!defined('ABSPATH')) {
    exit; // Previne acesso direto
}

class Strategya_Content_Builder {
    
    private $seo_keywords = [];
    private $content_structure = [];
    private $language = 'pt-BR';
    
    /**
     * Construtor da classe
     */
    public function __construct() {
        $this->init_hooks();
    }
    
    /**
     * Inicializa hooks do WordPress
     */
    private function init_hooks() {
        add_filter('strategya_build_content', [$this, 'build_article_content'], 10, 2);
        add_filter('strategya_optimize_seo', [$this, 'optimize_for_seo'], 10, 2);
    }
    
    /**
     * Constrói o conteúdo completo do artigo
     * 
     * @param string $ai_content Conteúdo gerado pela IA
     * @param array $params Parâmetros de construção
     * @return array Conteúdo estruturado
     */
    public function build_article_content($ai_content, $params = []) {
        try {
            // Valida o conteúdo de entrada
            if (empty($ai_content)) {
                throw new Exception('Conteúdo IA não pode estar vazio');
            }
            
            // Processa o conteúdo
            $structured_content = $this->parse_ai_content($ai_content);
            $optimized_content = $this->optimize_content_structure($structured_content);
            
            // Gera elementos WordPress
            $post_data = [
                'title' => $this->extract_title($optimized_content),
                'content' => $this->format_content($optimized_content),
                'excerpt' => $this->generate_excerpt($optimized_content),
                'meta_description' => $this->generate_meta_description($optimized_content),
                'tags' => $this->extract_tags($optimized_content),
                'seo_score' => $this->calculate_seo_score($optimized_content)
            ];
            
            return $post_data;
            
        } catch (Exception $e) {
            error_log('Strategya Content Builder Error: ' . $e->getMessage());
            return false;
        }
    }
    
    /**
     * Analisa e estrutura o conteúdo gerado pela IA
     * 
     * @param string $content Conteúdo bruto
     * @return array Conteúdo estruturado
     */
    private function parse_ai_content($content) {
        $structure = [];
        
        // Extrai título
        if (preg_match('/^#\s*(.+)$/m', $content, $matches)) {
            $structure['title'] = trim($matches[1]);
        }
        
        // Extrai subtítulos H2
        preg_match_all('/^##\s*(.+)$/m', $content, $h2_matches);
        $structure['h2_headings'] = $h2_matches[1];
        
        // Extrai subtítulos H3
        preg_match_all('/^###\s*(.+)$/m', $content, $h3_matches);
        $structure['h3_headings'] = $h3_matches[1];
        
        // Extrai parágrafos
        $paragraphs = explode("\n\n", $content);
        $structure['paragraphs'] = array_filter($paragraphs, function($p) {
            return !empty(trim($p)) && !preg_match('/^#{1,3}\s/', $p);
        });
        
        // Extrai listas
        preg_match_all('/^[\*\-]\s*(.+)$/m', $content, $list_matches);
        $structure['lists'] = $list_matches[1];
        
        $structure['raw_content'] = $content;
        
        return $structure;
    }
    
    /**
     * Otimiza a estrutura do conteúdo para SEO
     * 
     * @param array $structure Estrutura do conteúdo
     * @return array Estrutura otimizada
     */
    private function optimize_content_structure($structure) {
        // Otimiza título
        if (isset($structure['title'])) {
            $structure['title'] = $this->optimize_title($structure['title']);
        }
        
        // Otimiza subtítulos H2
        if (isset($structure['h2_headings'])) {
            $structure['h2_headings'] = array_map([$this, 'optimize_heading'], $structure['h2_headings']);
        }
        
        // Adiciona palavras-chave nos parágrafos
        if (isset($structure['paragraphs'])) {
            $structure['paragraphs'] = $this->optimize_paragraphs($structure['paragraphs']);
        }
        
        // Extrai palavras-chave
        $structure['keywords'] = $this->extract_keywords($structure['raw_content']);
        
        return $structure;
    }
    
    /**
     * Otimiza o título para SEO
     * 
     * @param string $title Título original
     * @return string Título otimizado
     */
    private function optimize_title($title) {
        // Remove caracteres especiais
        $title = preg_replace('/[^\w\s\-\u00C0-\u017F]/u', '', $title);
        
        // Limita o comprimento (ideal: 50-60 caracteres)
        if (strlen($title) > 60) {
            $title = substr($title, 0, 57) . '...';
        }
        
        // Adiciona chamada para ação se apropriado
        if (strpos(strtolower($title), 'como') !== false) {
            $title = rtrim($title, '.') . ' | Guia Completo';
        }
        
        return trim($title);
    }
    
    /**
     * Otimiza subtítulos
     * 
     * @param string $heading Subtítulo original
     * @return string Subtítulo otimizado
     */
    private function optimize_heading($heading) {
        // Remove caracteres especiais
        $heading = preg_replace('/[^\w\s\-\u00C0-\u017F]/u', '', $heading);
        
        // Capitaliza adequadamente
        $heading = ucwords(strtolower($heading));
        
        return trim($heading);
    }
    
    /**
     * Otimiza parágrafos para SEO
     * 
     * @param array $paragraphs Lista de parágrafos
     * @return array Parágrafos otimizados
     */
    private function optimize_paragraphs($paragraphs) {
        $optimized = [];
        
        foreach ($paragraphs as $paragraph) {
            // Remove linhas vazias
            $paragraph = trim($paragraph);
            
            if (empty($paragraph)) continue;
            
            // Garante que parágrafos tenham pelo menos 2 frases
            $sentences = preg_split('/[.!?]+/', $paragraph);
            $sentences = array_filter($sentences, function($s) {
                return !empty(trim($s));
            });
            
            if (count($sentences) >= 2) {
                $optimized[] = $paragraph;
            }
        }
        
        return $optimized;
    }
    
    /**
     * Extrai título do conteúdo estruturado
     * 
     * @param array $content Conteúdo estruturado
     * @return string Título
     */
    private function extract_title($content) {
        return isset($content['title']) ? $content['title'] : 'Título não disponível';
    }
    
    /**
     * Formata o conteúdo para WordPress
     * 
     * @param array $content Conteúdo estruturado
     * @return string Conteúdo formatado HTML
     */
    private function format_content($content) {
        $html = '';
        
        // Adiciona parágrafos
        if (isset($content['paragraphs'])) {
            foreach ($content['paragraphs'] as $paragraph) {
                $html .= '<p>' . wp_kses_post($paragraph) . '</p>';
            }
        }
        
        // Adiciona subtítulos H2
        if (isset($content['h2_headings'])) {
            foreach ($content['h2_headings'] as $heading) {
                $html .= '<h2>' . wp_kses_post($heading) . '</h2>';
            }
        }
        
        // Adiciona listas
        if (isset($content['lists']) && !empty($content['lists'])) {
            $html .= '<ul>';
            foreach ($content['lists'] as $item) {
                $html .= '<li>' . wp_kses_post($item) . '</li>';
            }
            $html .= '</ul>';
        }
        
        return $html;
    }
    
    /**
     * Gera excerpt otimizado
     * 
     * @param array $content Conteúdo estruturado
     * @return string Excerpt
     */
    private function generate_excerpt($content) {
        $excerpt = '';
        
        if (isset($content['paragraphs']) && !empty($content['paragraphs'])) {
            $first_paragraph = $content['paragraphs'][0];
            $excerpt = wp_trim_words($first_paragraph, 25, '...');
        }
        
        // Garante que o excerpt tenha entre 120-160 caracteres
        if (strlen($excerpt) > 160) {
            $excerpt = substr($excerpt, 0, 157) . '...';
        }
        
        return $excerpt;
    }
    
    /**
     * Gera meta description otimizada
     * 
     * @param array $content Conteúdo estruturado
     * @return string Meta description
     */
    private function generate_meta_description($content) {
        $meta_desc = '';
        
        if (isset($content['paragraphs']) && !empty($content['paragraphs'])) {
            $first_paragraph = $content['paragraphs'][0];
            $meta_desc = wp_trim_words($first_paragraph, 20, '');
        }
        
        // Garante que tenha exatamente 155 caracteres
        if (strlen($meta_desc) > 155) {
            $meta_desc = substr($meta_desc, 0, 152) . '...';
        }
        
        return $meta_desc;
    }
    
    /**
     * Extrai tags relevantes
     * 
     * @param array $content Conteúdo estruturado
     * @return array Tags
     */
    private function extract_tags($content) {
        $tags = [];
        
        if (isset($content['keywords'])) {
            $tags = array_slice($content['keywords'], 0, 10);
        }
        
        // Adiciona tags padrão para comunidade estrangeira no Japão
        $default_tags = ['japao', 'estrangeiros', 'comunidade', 'noticias'];
        $tags = array_merge($tags, $default_tags);
        
        return array_unique($tags);
    }
    
    /**
     * Extrai palavras-chave do conteúdo
     * 
     * @param string $content Conteúdo bruto
     * @return array Palavras-chave
     */
    private function extract_keywords($content) {
        // Remove pontuação e converte para minúsculas
        $clean_content = strtolower(preg_replace('/[^\w\s\u00C0-\u017F]/u', ' ', $content));
        
        // Separa em palavras
        $words = preg_split('/\s+/', $clean_content);
        
        // Remove palavras muito curtas ou stopwords
        $stopwords = ['de', 'da', 'do', 'em', 'um', 'uma', 'com', 'por', 'para', 'que', 'como', 'mais', 'muito', 'ser', 'ter', 'seu', 'sua'];
        
        $filtered_words = array_filter($words, function($word) use ($stopwords) {
            return strlen($word) >= 4 && !in_array($word, $stopwords);
        });
        
        // Conta frequência das palavras
        $word_count = array_count_values($filtered_words);
        
        // Ordena por frequência
        arsort($word_count);
        
        // Retorna as 15 palavras mais frequentes
        return array_slice(array_keys($word_count), 0, 15);
    }
    
    /**
     * Calcula score SEO do conteúdo
     * 
     * @param array $content Conteúdo estruturado
     * @return int Score de 0 a 100
     */
    private function calculate_seo_score($content) {
        $score = 0;
        
        // Verifica título (20 pontos)
        if (isset($content['title']) && strlen($content['title']) >= 30) {
            $score += 20;
        }
        
        // Verifica subtítulos H2 (20 pontos)
        if (isset($content['h2_headings']) && count($content['h2_headings']) >= 2) {
            $score += 20;
        }
        
        // Verifica número de parágrafos (20 pontos)
        if (isset($content['paragraphs']) && count($content['paragraphs']) >= 5) {
            $score += 20;
        }
        
        // Verifica comprimento do conteúdo (20 pontos)
        $content_length = strlen($content['raw_content']);
        if ($content_length >= 1500) {
            $score += 20;
        } elseif ($content_length >= 1000) {
            $score += 10;
        }
        
        // Verifica palavras-chave (20 pontos)
        if (isset($content['keywords']) && count($content['keywords']) >= 10) {
            $score += 20;
        }
        
        return min($score, 100);
    }
    
    /**
     * Otimiza conteúdo para EEAT
     * 
     * @param array $content Conteúdo estruturado
     * @param array $author_info Informações do autor
     * @return array Conteúdo otimizado
     */
    public function optimize_for_eeat($content, $author_info = []) {
        // Adiciona informações de credibilidade
        if (isset($content['raw_content'])) {
            $content['raw_content'] = $this->add_credibility_signals($content['raw_content']);
        }
        
        // Adiciona informações do autor
        if (!empty($author_info)) {
            $content['author_info'] = $author_info;
        }
        
        // Adiciona data de publicação
        $content['publish_date'] = current_time('mysql');
        
        return $content;
    }
    
    /**
     * Adiciona sinais de credibilidade ao conteúdo
     * 
     * @param string $content Conteúdo
     * @return string Conteúdo com sinais de credibilidade
     */
    private function add_credibility_signals($content) {
        // Adiciona frases que demonstram experiência
        $experience_phrases = [
            'Com base em nossa experiência',
            'Segundo especialistas',
            'De acordo com dados oficiais',
            'Conforme relatado por fontes confiáveis'
        ];
        
        // Adiciona chamadas para fontes confiáveis
        $content .= "\n\n" . '## Fontes e Referências' . "\n";
        $content .= 'Este artigo foi baseado em informações de fontes oficiais e confiáveis.';
        
        return $content;
    }
    
    /**
     * Define o idioma do conteúdo
     * 
     * @param string $language Código do idioma
     */
    public function set_language($language) {
        $this->language = $language;
    }
    
    /**
     * Obtém o idioma atual
     * 
     * @return string Código do idioma
     */
    public function get_language() {
        return $this->language;
    }
}

// Inicializa a classe
new Strategya_Content_Builder();

?>
            

        

    



    
    
    
    


    
    
    post-generator.php - Gerador de Posts WordPress
    
    
    
    
    


    

        

            

                
                

                    
post-generator.php

                    
Gerador de Posts WordPress - Strategya AI News Generator

                

            


            

                

                    Funcionalidades
                

                

                    

                        
                        Criação Automática de Posts
                        
Gera posts com conteúdo otimizado

                    

                    

                        
                        Categorias e Tags
                        
Organização automática de conteúdo

                    

                    

                        
                        SEO Otimizado
                        
Meta descriptions e títulos SEO

                    

                    

                        
                        Validação Segura
                        
Sanitização e verificação de dados

                    

                

            


            

                

                    Código PHP
                

                

                    

                

            


            

                

                    Recursos Avançados
                

                

                    

                        
Processamento em Lote

                        
Criação de múltiplos posts simultaneamente com controle de performance

                    

                    

                        
Schema.org

                        
Markup estruturado automático para melhor indexação nos motores de busca

                    

                    

                        
Compatibilidade SEO

                        
Integração com Yoast SEO e All in One SEO Pack

                    

                

            


            

                

                    Características Exclusivas
                

                
    
                    
  • 
                        
                        
    
                            Criação Automática de Categorias: Gera categorias dinamicamente se não existirem
                        
    
                    
    • 
                    
  • 
                        
                        
    
                            Cálculo de Tempo de Leitura: Estima automaticamente o tempo necessário para leitura
                        
    
                    
    • 
                    
  • 
                        
                        
    
                            Log Detalhado: Mantém histórico completo de todos os posts gerados
                        
    
                    
    • 
                    
  • 
                        
                        
    
                            Controle de Performance: Pausas automáticas para evitar sobrecarga do servidor
                        
    
                    
    • 
                    
  • 
                        
                        
    
                            Estatísticas Avançadas: Métricas detalhadas sobre posts gerados e performance SEO
                        
    
                    
    • 
                

            


            

                

                    
                    Strategya Co., Ltd. - Sistema Exclusivo de Geração de Conteúdo