消息API

{
  "id": "msg1234567890",
  "chat_id": "chat1234567890",
  "sender_id": "user1234567890",
  "type": "text",
  "content": {
    // 根据消息类型不同而变化
  },
  "timestamp": 1625097600000,
  "status": "read",
  "edited": false,
  "forwarded": false,
  "reply_to_message_id": null,
  "expire_in": 0
}

wss://api.paperplane.com/v8/ws?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

{
  "type": "message",
  "data": {
    "id": "msg1234567890",
    "chat_id": "chat1234567890",
    "sender_id": "user1234567890",
    "type": "text",
    "content": {
      "text": "Hello, this is a test message!"
    },
    "timestamp": 1625097600000,
    "status": "sent",
    "edited": false,
    "forwarded": false,
    "reply_to_message_id": null,
    "expire_in": 0
  }
}

{
  "ok": false,
  "error": {
    "code": "MESSAGE_TOO_LONG",
    "message": "Message text is too long. Maximum allowed length is 4096 characters.",
    "status_code": 400
  }
}

// 发送文本消息
async function sendTextMessage(chatId, text) {
  try {
    const response = await fetch('https://api.paperplane.com/v8/messages/send', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${localStorage.getItem('accessToken')}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        chat_id: chatId,
        type: 'text',
        content: {
          text: text
        }
      })
    });
    
    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(errorData.error?.message || 'Failed to send message');
    }
    
    const data = await response.json();
    return data.result;
  } catch (error) {
    console.error('Error sending message:', error);
    throw error;
  }
}

// 使用WebSocket接收消息
function connectWebSocket() {
  const token = localStorage.getItem('accessToken');
  const ws = new WebSocket(`wss://api.paperplane.com/v8/ws?token=${token}`);
  
  ws.onopen = () => {
    console.log('WebSocket connected');
  };
  
  ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    
    switch (data.type) {
      case 'message':
        console.log('New message received:', data.data);
        // 处理新消息
        break;
      case 'message_status':
        console.log('Message status updated:', data.data);
        // 处理消息状态更新
        break;
      case 'typing':
        console.log('User is typing:', data.data);
        // 处理正在输入状态
        break;
      // 处理其他事件类型
    }
  };
  
  ws.onclose = () => {
    console.log('WebSocket disconnected');
    // 可以在这里实现重连逻辑
    setTimeout(connectWebSocket, 5000);
  };
  
  ws.onerror = (error) => {
    console.error('WebSocket error:', error);
  };
  
  return ws;
}

// 使用示例
sendTextMessage('chat1234567890', 'Hello from JavaScript!')
  .then(message => console.log('Message sent:', message))
  .catch(error => console.error('Failed to send message:', error));

const ws = connectWebSocket();

import requests
import json
import websocket
import threading
import time

# 发送文本消息
def send_text_message(chat_id, text, token):
    url = 'https://api.paperplane.com/v8/messages/send'
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/json'
    }
    data = {
        'chat_id': chat_id,
        'type': 'text',
        'content': {
            'text': text
        }
    }
    
    try:
        response = requests.post(url, headers=headers, data=json.dumps(data))
        response.raise_for_status()
        
        result = response.json()
        return result['result']
    except requests.exceptions.HTTPError as http_err:
        error_data = response.json()
        print(f'HTTP error occurred: {error_data.get("error", {}).get("message", "Unknown error")}')
        raise
    except Exception as err:
        print(f'Other error occurred: {err}')
        raise

# WebSocket消息处理
def on_message(ws, message):
    data = json.loads(message)
    
    if data['type'] == 'message':
        print(f'New message received: {data["data"]}')
        # 处理新消息
    elif data['type'] == 'message_status':
        print(f'Message status updated: {data["data"]}')
        # 处理消息状态更新
    elif data['type'] == 'typing':
        print(f'User is typing: {data["data"]}')
        # 处理正在输入状态
    # 处理其他事件类型

def on_error(ws, error):
    print(f'WebSocket error: {error}')

def on_close(ws):
    print('WebSocket disconnected')
    # 实现重连逻辑
    time.sleep(5)
    connect_websocket(token)

def on_open(ws):
    print('WebSocket connected')

def connect_websocket(token):
    ws_url = f'wss://api.paperplane.com/v8/ws?token={token}'
    ws = websocket.WebSocketApp(
        ws_url,
        on_open=on_open,
        on_message=on_message,
        on_error=on_error,
        on_close=on_close
    )
    
    # 在后台线程中运行WebSocket
    ws_thread = threading.Thread(target=ws.run_forever)
    ws_thread.daemon = True
    ws_thread.start()
    
    return ws

# 使用示例
if __name__ == '__main__':
    token = 'your_access_token_here'
    
    # 发送消息
    try:
        message = send_text_message('chat1234567890', 'Hello from Python!', token)
        print(f'Message sent: {message}')
    except Exception as e:
        print(f'Failed to send message: {e}')
    
    # 连接WebSocket
    ws = connect_websocket(token)
    
    # 保持程序运行
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print('Program terminated')
        ws.close()