OAuth2对接

const authUrl = 'https://conn.nodeloc.cc/oauth2/auth?' + new URLSearchParams({
  response_type: 'code',
  client_id: 'YOUR_CLIENT_ID',
  redirect_uri: 'https://myapp.com/callback',
  scope: 'openid profile',
  state: 'random_state_string'
});

window.location.href = authUrl;

const response = await fetch('https://conn.nodeloc.cc/oauth2/token', {
  method: 'POST',
  headers: {
    'Authorization': 'Basic ' + btoa('CLIENT_ID:CLIENT_SECRET'),
    'Content-Type': 'application/x-www-form-urlencoded'
  },
  body: new URLSearchParams({
    grant_type: 'authorization_code',
    code: 'authorization_code_here',
    redirect_uri: 'https://myapp.com/callback'
  })
});

const tokens = await response.json();

const userResponse = await fetch('https://conn.nodeloc.cc/oauth2/userinfo', {
  headers: {
    'Authorization': 'Bearer ' + access_token
  }
});

const userInfo = await userResponse.json();

class NodeLocOAuth2Client {
  constructor(clientId, clientSecret, redirectUri) {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.redirectUri = redirectUri;
    this.baseUrl = 'https://conn.nodeloc.cc';
  }

  // 生成授权URL
  getAuthUrl(state = null) {
    const params = new URLSearchParams({
      response_type: 'code',
      client_id: this.clientId,
      redirect_uri: this.redirectUri,
      scope: 'openid profile'
    });
    
    if (state) params.append('state', state);
    return `${this.baseUrl}/oauth2/auth?${params}`;
  }

  // 交换访问令牌
  async exchangeCodeForTokens(code) {
    const response = await fetch(`${this.baseUrl}/oauth2/token`, {
      method: 'POST',
      headers: {
        'Authorization': 'Basic ' + btoa(`${this.clientId}:${this.clientSecret}`),
        'Content-Type': 'application/x-www-form-urlencoded'
      },
      body: new URLSearchParams({
        grant_type: 'authorization_code',
        code: code,
        redirect_uri: this.redirectUri
      })
    });

    if (!response.ok) {
      throw new Error(`Token exchange failed: ${response.status}`);
    }
    return await response.json();
  }

  // 获取用户信息
  async getUserInfo(accessToken) {
    const response = await fetch(`${this.baseUrl}/oauth2/userinfo`, {
      headers: { 'Authorization': `Bearer ${accessToken}` }
    });

    if (!response.ok) {
      throw new Error(`Get user info failed: ${response.status}`);
    }
    return await response.json();
  }

  // 刷新令牌
  async refreshToken(refreshToken) {
    const response = await fetch(`${this.baseUrl}/oauth2/token`, {
      method: 'POST',
      headers: {
        'Authorization': 'Basic ' + btoa(`${this.clientId}:${this.clientSecret}`),
        'Content-Type': 'application/x-www-form-urlencoded'
      },
      body: new URLSearchParams({
        grant_type: 'refresh_token',
        refresh_token: refreshToken
      })
    });

    if (!response.ok) {
      throw new Error(`Token refresh failed: ${response.status}`);
    }
    return await response.json();
  }

  // 解析JWT ID Token
  parseJwtToken(token) {
    const base64Url = token.split('.')[1];
    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
    const jsonPayload = decodeURIComponent(
      atob(base64).split('').map(c => 
        '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)
      ).join('')
    );
    return JSON.parse(jsonPayload);
  }
}

import requests
import base64
import json
from urllib.parse import urlencode

class NodeLocOAuth2Client:
    def __init__(self, client_id, client_secret, redirect_uri):
        self.client_id = client_id
        self.client_secret = client_secret
        self.redirect_uri = redirect_uri
        self.base_url = 'https://conn.nodeloc.cc'
    
    def get_auth_url(self, state=None):
        params = {
            'response_type': 'code',
            'client_id': self.client_id,
            'redirect_uri': self.redirect_uri,
            'scope': 'openid profile'
        }
        if state:
            params['state'] = state
        return f"{self.base_url}/oauth2/auth?{urlencode(params)}"
    
    def exchange_code_for_tokens(self, code):
        auth_header = base64.b64encode(
            f"{self.client_id}:{self.client_secret}".encode()
        ).decode()
        
        response = requests.post(
            f"{self.base_url}/oauth2/token",
            data={
                'grant_type': 'authorization_code',
                'code': code,
                'redirect_uri': self.redirect_uri
            },
            headers={
                'Authorization': f'Basic {auth_header}',
                'Content-Type': 'application/x-www-form-urlencoded'
            }
        )
        response.raise_for_status()
        return response.json()
    
    def get_user_info(self, access_token):
        response = requests.get(
            f"{self.base_url}/oauth2/userinfo",
            headers={'Authorization': f'Bearer {access_token}'}
        )
        response.raise_for_status()
        return response.json()

async function handleOAuthError(error) {
  if (error.message.includes('invalid_client')) {
    console.error('客户端认证失败，请检查Client ID和Secret');
    // 重定向到配置页面
  } else if (error.message.includes('invalid_grant')) {
    console.error('授权码无效或过期，重新获取授权');
    // 重新发起授权流程
    window.location.href = oauth2Client.getAuthUrl();
  } else {
    console.error('未知OAuth错误:', error);
    // 显示通用错误信息
  }
}