Configurações - D.Pedro Soluções

Configurações Gerais

Informações da Empresa

Nome da Empresa

Email da Empresa

Telefone

Website

Endereço

Preferências do Sistema

Idioma

Moeda

Formato de Data

Formato de Hora

Personalização da Aparência

Tema

Modo Escuro

Ativar/Desativar

Tema do Sistema

Cores Personalizadas

Cor Primária

Cor Secundária

Cor de Destaque

Cor de Sucesso

Layout

Layout do Menu

Densidade de Informação

Configurações de Notificações

Configure como e quando receber notificações do sistema.

Configurações de Segurança

Gerencie as configurações de segurança e privacidade do sistema.

Backup e Restauração

Backup do Sistema

Último backup: Nunca

Próximo backup automático: -

Tamanho do backup: -

Frequência de Backup

Hora do Backup

Itens para Backup

Projetos Clientes Configurações Atividades

Histórico de Backups

Nenhum backup encontrado.

Integrações

Configure integrações com outros serviços e plataformas.

Configurações Avançadas

Acesse configurações avançadas do sistema.

Configurações da API e Servidor

Status do Servidor

Verificando status do servidor...

Testar Conexões

Configurações do Servidor

URL Base da API

Timeout (ms)

Chave da API OpenAI

Código do Servidor

Servidor Express.js

// =============================================
// SERVIDOR D.PEDRO SOLUÇÕES - API INTEGRADA
// =============================================

const express = require('express');
const cors = require('cors');
const OpenAI = require('openai');
require('dotenv').config();

const app = express();
const port = process.env.PORT || 3000;

// Middleware
app.use(cors());
app.use(express.json());

// Configuração segura da OpenAI com o novo endpoint
const openai = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY
});

// Armazenamento em memória
let messageHistory = [];
let supportTickets = [];
let workflows = [];

// Rotas de Saúde
app.get('/api/health', (req, res) => {
    res.json({ 
        status: 'online', 
        service: 'D.Pedro Soluções - API Integrada',
        timestamp: new Date().toISOString(),
        openai: 'Configurado'
    });
});

// Rota principal usando o novo endpoint responses
app.post('/api/chat', async (req, res) => {
    try {
        const { 
            messages, 
            model = "gpt-4o-mini", 
            max_tokens = 500, 
            temperature = 0.7,
            store = true 
        } = req.body;

        // Formatar input para o novo endpoint
        const input = Array.isArray(messages) ? messages.join('\n') : messages;

        const response = await openai.responses.create({
            model: model,
            input: input,
            temperature: temperature,
            max_output_tokens: max_tokens,
            store: store
        });

        // Salvar no histórico
        const aiResponse = {
            id: response.id,
            input: input,
            output: response.output[0].content[0].text,
            timestamp: new Date().toISOString(),
            usage: response.usage,
            model: response.model
        };

        messageHistory.push(aiResponse);

        // Manter apenas os últimos 100 registros
        if (messageHistory.length > 100) {
            messageHistory = messageHistory.slice(-100);
        }

        res.json({
            success: true,
            response: response.output[0].content[0].text,
            usage: response.usage,
            id: response.id,
            model: response.model
        });

    } catch (error) {
        console.error('Erro OpenAI:', error);
        res.status(500).json({
            success: false,
            error: error.message
        });
    }
});

// Rota para análise de sentimentos
app.post('/api/analyze-sentiment', async (req, res) => {
    try {
        const { text } = req.body;

        const response = await openai.responses.create({
            model: "gpt-4o-mini",
            input: `Analise o sentimento deste texto em português e retorne APENAS uma palavra: positivo, negativo ou neutro: "${text}"`,
            temperature: 0.3,
            max_output_tokens: 10,
            store: false
        });

        const sentiment = response.output[0].content[0].text.trim().toLowerCase();

        res.json({
            success: true,
            sentiment: sentiment,
            confidence: "high"
        });

    } catch (error) {
        console.error('Erro análise de sentimento:', error);
        res.status(500).json({ success: false, error: error.message });
    }
});

// Rota para geração de respostas automáticas
app.post('/api/generate-response', async (req, res) => {
    try {
        const { context, userMessage, channel, history = [] } = req.body;

        const prompt = `Você é um assistente especializado da D.Pedro Soluções.

CONTEXTO:
- Canal: ${channel}
- Situação: ${context}
- Histórico recente: ${history.slice(-3).map(msg => `${msg.sender}: ${msg.text}`).join('\n')}

MENSAGEM DO CLIENTE:
"${userMessage}"

INSTRUÇÕES:
- Responda em português de forma profissional e útil
- Seja empático e solucione problemas
- Mantenha a resposta concisa
- Ofereça ajuda adicional se necessário

RESPOSTA:`;

        const response = await openai.responses.create({
            model: "gpt-4o-mini",
            input: prompt,
            temperature: 0.7,
            max_output_tokens: 250,
            store: true
        });

        const aiResponse = response.output[0].content[0].text;

        res.json({
            success: true,
            response: aiResponse,
            channel: channel,
            timestamp: new Date().toISOString(),
            id: response.id
        });

    } catch (error) {
        console.error('Erro geração de resposta:', error);
        res.status(500).json({ success: false, error: error.message });
    }
});

// Rota para criação de histórias (demonstração)
app.post('/api/create-story', async (req, res) => {
    try {
        const { theme = "unicorn", style = "bedtime story" } = req.body;

        const response = await openai.responses.create({
            model: "gpt-4o-mini",
            input: `Crie uma ${style} em português sobre ${theme}. Seja criativo e mágico, em 3-4 frases.`,
            temperature: 1.0,
            max_output_tokens: 150,
            store: true
        });

        res.json({
            success: true,
            story: response.output[0].content[0].text,
            theme: theme,
            style: style,
            id: response.id
        });

    } catch (error) {
        console.error('Erro criação de história:', error);
        res.status(500).json({ success: false, error: error.message });
    }
});

// Rota para sugestão de fluxos de trabalho
app.post('/api/suggest-workflow', async (req, res) => {
    try {
        const { process, goals, constraints } = req.body;

        const response = await openai.responses.create({
            model: "gpt-4o-mini",
            input: `Sugira um fluxo de trabalho automatizado para: ${process}
Objetivos: ${goals}
Restrições: ${constraints}

Forneça uma sugestão em português com 3-5 etapas.`,
            temperature: 0.8,
            max_output_tokens: 300,
            store: true
        });

        res.json({
            success: true,
            workflow: response.output[0].content[0].text,
            process: process,
            id: response.id
        });

    } catch (error) {
        console.error('Erro sugestão de workflow:', error);
        res.status(500).json({ success: false, error: error.message });
    }
});

// Rota para geração de documentos
app.post('/api/generate-document', async (req, res) => {
    try {
        const { type, context, variables = {} } = req.body;

        const prompts = {
            contract: `Gere um contrato de serviços para: ${context}
Variáveis: ${JSON.stringify(variables)}
Formato profissional em português.`,
            proposal: `Gere uma proposta comercial para: ${context}
Destaque benefícios e valores.`,
            report: `Gere um relatório executivo sobre: ${context}
Inclua análise e recomendações.`
        };

        const response = await openai.responses.create({
            model: "gpt-4o-mini",
            input: prompts[type] || `Gere um documento do tipo ${type} para: ${context}`,
            temperature: 0.5,
            max_output_tokens: 500,
            store: true
        });

        res.json({
            success: true,
            document: response.output[0].content[0].text,
            type: type,
            generated_at: new Date().toISOString(),
            id: response.id
        });

    } catch (error) {
        console.error('Erro geração de documento:', error);
        res.status(500).json({ success: false, error: error.message });
    }
});

// Rota para análise de dados de negócio
app.post('/api/business-insights', async (req, res) => {
    try {
        const { data, focus_areas = [] } = req.body;

        const response = await openai.responses.create({
            model: "gpt-4o-mini",
            input: `Analise estes dados de negócio e forneça insights acionáveis em português:
${JSON.stringify(data, null, 2)}

Áreas de foco: ${focus_areas.join(', ')}

Forneça:
1. Análise de tendências
2. Oportunidades identificadas
3. Recomendações específicas
4. Métricas para acompanhar`,
            temperature: 0.7,
            max_output_tokens: 600,
            store: true
        });

        res.json({
            success: true,
            insights: response.output[0].content[0].text,
            focus_areas: focus_areas,
            id: response.id
        });

    } catch (error) {
        console.error('Erro análise de negócio:', error);
        res.status(500).json({ success: false, error: error.message });
    }
});

// Gestão de Tickets de Suporte
app.post('/api/support/tickets', (req, res) => {
    try {
        const ticket = {
            id: 'T' + Date.now(),
            ...req.body,
            status: 'aberto',
            created_at: new Date().toISOString(),
            updated_at: new Date().toISOString()
        };

        supportTickets.push(ticket);

        res.json({
            success: true,
            ticket: ticket,
            total_tickets: supportTickets.length
        });

    } catch (error) {
        res.status(500).json({ success: false, error: error.message });
    }
});

app.get('/api/support/tickets', (req, res) => {
    res.json({
        success: true,
        tickets: supportTickets,
        stats: {
            total: supportTickets.length,
            open: supportTickets.filter(t => t.status === 'aberto').length,
            closed: supportTickets.filter(t => t.status === 'fechado').length
        }
    });
});

// Histórico de interações com IA
app.get('/api/ai/history', (req, res) => {
    res.json({
        success: true,
        history: messageHistory,
        total_interactions: messageHistory.length
    });
});

// Estatísticas do sistema
app.get('/api/stats', (req, res) => {
    res.json({
        success: true,
        stats: {
            messages_processed: messageHistory.length,
            active_tickets: supportTickets.filter(t => t.status === 'aberto').length,
            active_workflows: workflows.filter(w => w.active).length,
            system_uptime: process.uptime(),
            memory_usage: process.memoryUsage()
        },
        timestamp: new Date().toISOString()
    });
});

// Teste de conexão com OpenAI
app.get('/api/test-openai', async (req, res) => {
    try {
        const response = await openai.responses.create({
            model: "gpt-4o-mini",
            input: "Escreva um haiku sobre inteligência artificial em português.",
            temperature: 0.7,
            max_output_tokens: 100,
            store: false
        });

        res.json({
            success: true,
            test: "conexão_ok",
            response: response.output[0].content[0].text,
            model: response.model,
            id: response.id
        });

    } catch (error) {
        res.status(500).json({
            success: false,
            test: "conexão_falhou",
            error: error.message
        });
    }
});

app.listen(port, () => {
    console.log(`🚀 Servidor D.Pedro Soluções rodando na porta ${port}`);
    console.log(`📊 API Health: http://localhost:${port}/api/health`);
    console.log(`🔗 Teste OpenAI: http://localhost:${port}/api/test-openai`);
    console.log(`🤖 Endpoint Responses: Configurado com sucesso`);
});

Configurações do Sistema