Usuário

A API da Nuvende permite consultar informações sobre o cliente autenticado, incluindo dados básicos de identificação e configurações da conta.

Como Funciona a Consulta de Usuário

O endpoint de usuário na API da Nuvende permite recuperar informações sobre o cliente autenticado. Quando você consulta o usuário:

1. Autenticação Necessária: É necessário um access token válido
2. Dados Básicos: Retorna informações de identificação do cliente
3. Informações da Conta: Inclui dados relacionados à conta do cliente
4. Segurança: Apenas o próprio cliente pode consultar suas informações

Por que Consultar Informações do Usuário?

• Identificação: Confirmar qual cliente está autenticado
• Personalização: Adaptar a interface baseada nos dados do cliente
• Validação: Verificar permissões e status da conta
• Auditoria: Registrar ações específicas do cliente

Implementação

Endpoint Oficial

URL: POST /api/v2/auth/user
Ambiente Homologação: https://api-h.nuvende.com.br/api/v2/auth/user
Ambiente Produção: https://api.nuvende.com.br/api/v2/auth/user

Headers Obrigatórios

• Authorization: Bearer {access_token} - Token de acesso válido

Exemplo de Requisição

curl -X POST https://api-h.nuvende.com.br/api/v2/auth/user \
  -H "Authorization: Bearer seu_access_token"

Resposta de Sucesso

{
  "client_id": "seu_client_id",
  "name": "Nome do Cliente"
}

Explicação da Resposta:

• client_id: Identificador único do cliente na API da Nuvende
• name: Nome do cliente conforme cadastrado

Implementação em Código

JavaScript/Node.js - Implementação Completa

Vamos integrar a consulta de usuário à classe NuvendeAuth que criamos nas páginas anteriores:

const axios = require('axios');

class NuvendeAuth {
  constructor(clientId, clientSecret, baseUrl) {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.baseUrl = baseUrl;
    this.accessToken = null;
    this.tokenExpiry = null;
  }

  // ... outros métodos da classe (getAccessToken, refreshAccessToken, logout, etc.) ...

  /**
   * Consulta informações do usuário autenticado
   * Retorna dados básicos do cliente conforme documentação oficial
   */
  async getUserInfo() {
    try {
      console.log('Consultando informações do usuário...');
      
      const response = await axios.post(`${this.baseUrl}/api/v2/auth/user`, {}, {
        headers: {
          'Authorization': `Bearer ${this.accessToken}`
        }
      });

      console.log('Informações do usuário obtidas com sucesso');
      return response.data;
      
    } catch (error) {
      console.error('Erro ao consultar usuário:', error.response?.data || error.message);
      throw error;
    }
  }

  /**
   * Faz uma requisição autenticada para qualquer endpoint
   * Automaticamente obtém o token se necessário
   */
  async makeAuthenticatedRequest(method, endpoint, data = null) {
    // Garantir que temos um token válido
    const token = await this.getValidAccessToken();
    
    const config = {
      method,
      url: `${this.baseUrl}${endpoint}`,
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      }
    };

    // Adicionar dados se fornecidos
    if (data) {
      config.data = data;
    }

    try {
      const response = await axios(config);
      return response;
    } catch (error) {
      // Se o token expirou, tentar obter um novo e refazer a requisição
      if (error.response?.status === 401) {
        console.log('Token expirado, obtendo novo token...');
        this.accessToken = null; // Forçar renovação
        const newToken = await this.getAccessToken();
        
        // Refazer a requisição com o novo token
        config.headers.Authorization = `Bearer ${newToken}`;
        return axios(config);
      }
      
      throw error;
    }
  }
}

// Exemplo de uso prático
async function exemploConsultaUsuario() {
  const nuvende = new NuvendeAuth(
    process.env.NUVENDE_CLIENT_ID,
    process.env.NUVENDE_CLIENT_SECRET,
    'https://api-h.nuvende.com.br'
  );

  try {
    // Fazer login primeiro
    await nuvende.getAccessToken();
    console.log('Login realizado');

    // Consultar informações do usuário
    const userInfo = await nuvende.getUserInfo();
    console.log('Informações do usuário:', userInfo);
    
    // Usar as informações para personalizar a aplicação
    console.log(`Cliente: ${userInfo.name} (ID: ${userInfo.client_id})`);

  } catch (error) {
    console.error('Erro:', error.response?.data || error.message);
  }
}

Python - Implementação Completa

import requests
import time
from datetime import datetime, timedelta

class NuvendeAuth:
    def __init__(self, client_id, client_secret, base_url):
        self.client_id = client_id
        self.client_secret = client_secret
        self.base_url = base_url
        self.access_token = None
        self.token_expiry = None

    # ... outros métodos da classe (get_access_token, refresh_access_token, logout, etc.) ...

    def get_user_info(self):
        """
        Consulta informações do usuário autenticado
        Retorna dados básicos do cliente conforme documentação oficial
        """
        try:
            print('Consultando informações do usuário...')
            
            headers = {
                'Authorization': f'Bearer {self.access_token}'
            }
            
            response = requests.post(
                f"{self.base_url}/api/v2/auth/user",
                headers=headers
            )
            
            response.raise_for_status()
            data = response.json()
            
            print('Informações do usuário obtidas com sucesso')
            return data
            
        except requests.exceptions.RequestException as e:
            print(f"Erro ao consultar usuário: {e}")
            raise

    def make_authenticated_request(self, method, endpoint, data=None):
        """
        Faz uma requisição autenticada para qualquer endpoint
        Automaticamente obtém o token se necessário
        """
        # Garantir que temos um token válido
        token = self.get_valid_access_token()
        
        headers = {
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }

        url = f"{self.base_url}{endpoint}"

        try:
            if method.upper() == 'GET':
                response = requests.get(url, headers=headers)
            elif method.upper() == 'POST':
                response = requests.post(url, headers=headers, json=data)
            elif method.upper() == 'PUT':
                response = requests.put(url, headers=headers, json=data)
            elif method.upper() == 'DELETE':
                response = requests.delete(url, headers=headers)
            else:
                raise ValueError(f"Método HTTP não suportado: {method}")
            
            response.raise_for_status()
            return response
            
        except requests.exceptions.RequestException as e:
            # Se o token expirou, tentar obter um novo e refazer a requisição
            if e.response and e.response.status_code == 401:
                print('Token expirado, obtendo novo token...')
                self.access_token = None  # Forçar renovação
                new_token = self.get_access_token()
                
                # Refazer a requisição com o novo token
                headers['Authorization'] = f'Bearer {new_token}'
                if method.upper() == 'GET':
                    return requests.get(url, headers=headers)
                elif method.upper() == 'POST':
                    return requests.post(url, headers=headers, json=data)
                elif method.upper() == 'PUT':
                    return requests.put(url, headers=headers, json=data)
                elif method.upper() == 'DELETE':
                    return requests.delete(url, headers=headers)
            
            raise

# Exemplo de uso prático
async def exemplo_consulta_usuario():
    nuvende = NuvendeAuth(
        os.getenv('NUVENDE_CLIENT_ID'),
        os.getenv('NUVENDE_CLIENT_SECRET'),
        'https://api-h.nuvende.com.br'
    )

    try:
        # Fazer login primeiro
        await nuvende.get_access_token()
        print('Login realizado')

        # Consultar informações do usuário
        user_info = await nuvende.get_user_info()
        print('Informações do usuário:', user_info)
        
        # Usar as informações para personalizar a aplicação
        print(f"Cliente: {user_info['name']} (ID: {user_info['client_id']})")

    except Exception as error:
        print(f'Erro: {error}')

Casos de Uso Práticos

1. Validação de Autenticação

// Verificar se o usuário está autenticado e obter informações básicas
async function validarAutenticacao() {
  try {
    const userInfo = await nuvende.getUserInfo();
    console.log(`Usuário autenticado: ${userInfo.name} (${userInfo.client_id})`);
    return true;
  } catch (error) {
    console.error('Usuário não autenticado:', error.message);
    return false;
  }
}

2. Personalização da Interface

// Usar informações do usuário para personalizar a aplicação
async function personalizarInterface() {
  try {
    const userInfo = await nuvende.getUserInfo();
    
    // Atualizar elementos da interface com dados do usuário
    document.getElementById('user-name').textContent = userInfo.name;
    document.getElementById('client-id').textContent = userInfo.client_id;
    
    // Mostrar/ocultar funcionalidades baseadas no cliente
    if (userInfo.client_id.startsWith('prod_')) {
      document.getElementById('production-features').style.display = 'block';
    }
    
  } catch (error) {
    console.error('Erro ao personalizar interface:', error.message);
  }
}

3. Auditoria e Logs

// Registrar ações do usuário para auditoria
async function registrarAcaoUsuario(acao, detalhes) {
  try {
    const userInfo = await nuvende.getUserInfo();
    
    const logEntry = {
      timestamp: new Date().toISOString(),
      client_id: userInfo.client_id,
      client_name: userInfo.name,
      acao: acao,
      detalhes: detalhes
    };
    
    console.log('Ação registrada:', logEntry);
    // Enviar para sistema de logs/auditoria
    
  } catch (error) {
    console.error('Erro ao registrar ação:', error.message);
  }
}

Tratamento de Erros

Códigos de Resposta HTTP

Implementação Robusta de Tratamento de Erros

class UserErrorHandler {
  static async handleUserError(error, nuvende) {
    const status = error.response?.status;
    const data = error.response?.data;
    
    switch (status) {
      case 401:
        console.error('❌ Token inválido ou expirado:', data);
        // Tentar renovar token
        try {
          await nuvende.refreshAccessToken();
          console.log('Token renovado, tentando novamente...');
          return await nuvende.getUserInfo();
        } catch (refreshError) {
          console.error('Falha na renovação do token:', refreshError);
          this.redirectToLogin();
        }
        break;
        
      case 500:
        console.error('❌ Erro interno do servidor:', data);
        // Tentar novamente após um tempo
        await this.retryUserRequest(nuvende);
        break;
        
      default:
        console.error('❌ Erro inesperado na consulta de usuário:', error.message);
        // Limpar tokens e forçar novo login
        nuvende.clearTokens();
        this.redirectToLogin();
    }
  }
  
  static async retryUserRequest(nuvende, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
      try {
        console.log(`Tentativa ${i + 1} de consulta de usuário...`);
        await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1))); // Backoff linear
        return await nuvende.getUserInfo();
      } catch (error) {
        console.error(`Falha na tentativa ${i + 1}:`, error.message);
        if (i === maxRetries - 1) {
          console.error('Todas as tentativas de consulta falharam');
          nuvende.clearTokens();
          this.redirectToLogin();
        }
      }
    }
  }
  
  static redirectToLogin() {
    // Implementar redirecionamento para página de login
    window.location.href = '/login';
  }
}

Boas Práticas

1. Cache de Informações do Usuário

class UserInfoCache {
  constructor(ttl = 300000) { // 5 minutos por padrão
    this.cache = null;
    this.timestamp = null;
    this.ttl = ttl;
  }
  
  async getUserInfo(nuvende) {
    const now = Date.now();
    
    // Verificar se o cache ainda é válido
    if (this.cache && this.timestamp && (now - this.timestamp) < this.ttl) {
      console.log('Retornando informações do usuário do cache');
      return this.cache;
    }
    
    // Buscar informações atualizadas
    console.log('Buscando informações atualizadas do usuário...');
    this.cache = await nuvende.getUserInfo();
    this.timestamp = now;
    
    return this.cache;
  }
  
  clearCache() {
    this.cache = null;
    this.timestamp = null;
    console.log('Cache de informações do usuário limpo');
  }
}

// Uso do cache
const userCache = new UserInfoCache();

async function obterInformacoesUsuario() {
  try {
    const userInfo = await userCache.getUserInfo(nuvende);
    return userInfo;
  } catch (error) {
    UserErrorHandler.handleUserError(error, nuvende);
  }
}

2. Validação de Dados

// Validar se as informações do usuário estão completas
function validarInformacoesUsuario(userInfo) {
  const erros = [];
  
  if (!userInfo.client_id) {
    erros.push('client_id é obrigatório');
  }
  
  if (!userInfo.name) {
    erros.push('name é obrigatório');
  }
  
  if (erros.length > 0) {
    throw new Error(`Informações do usuário inválidas: ${erros.join(', ')}`);
  }
  
  return true;
}

// Usar validação
async function obterUsuarioValidado() {
  try {
    const userInfo = await nuvende.getUserInfo();
    validarInformacoesUsuario(userInfo);
    return userInfo;
  } catch (error) {
    console.error('Erro na validação:', error.message);
    throw error;
  }
}