Примеры кода

JavaScript / TypeScript

Базовая настройка

                        // api.js
const API_BASE_URL = 'https://api.enot.space';

class EnotAPI {
  constructor(token) {
    this.token = token;
  }

  async request(endpoint, options = {}) {
    const url = `${API_BASE_URL}${endpoint}`;
    const headers = {
      'Content-Type': 'application/json',
      ...options.headers,
    };

    if (this.token) {
      headers['Authorization'] = `Bearer ${this.token}`;
    }

    const response = await fetch(url, {
      ...options,
      headers,
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.message);
    }

    return await response.json();
  }

  // Auth
  async register(username, email, password) {
    return this.request('/api/auth/register', {
      method: 'POST',
      body: JSON.stringify({ username, email, password }),
    });
  }

  async login(username, password) {
    return this.request('/api/auth/login', {
      method: 'POST',
      body: JSON.stringify({ username, password }),
    });
  }

  async getMe() {
    return this.request('/api/auth/me');
  }

  // Servers
  async getServers() {
    return this.request('/api/servers');
  }

  async createServer(name, description) {
    return this.request('/api/servers', {
      method: 'POST',
      body: JSON.stringify({ name, description }),
    });
  }

  // Messages
  async getMessages(channelId, limit = 50, offset = 0) {
    return this.request(`/api/channels/${channelId}/messages?limit=${limit}&offset=${offset}`);
  }

  async sendMessage(channelId, content) {
    return this.request(`/api/channels/${channelId}/messages`, {
      method: 'POST',
      body: JSON.stringify({ content }),
    });
  }
}

export default EnotAPI;
                    

WebSocket подключение

                        // websocket.js
class EnotWebSocket {
  constructor(token) {
    this.token = token;
    this.ws = null;
    this.reconnectAttempts = 0;
    this.maxReconnectAttempts = 5;
    this.handlers = {};
  }

  connect() {
    this.ws = new WebSocket(`wss://api.enot.space/ws?token=${this.token}`);

    this.ws.onopen = () => {
      console.log('WebSocket connected');
      this.reconnectAttempts = 0;
    };

    this.ws.onmessage = (event) => {
      const message = JSON.parse(event.data);
      this.handleMessage(message);
    };

    this.ws.onerror = (error) => {
      console.error('WebSocket error:', error);
    };

    this.ws.onclose = () => {
      console.log('WebSocket disconnected');
      this.reconnect();
    };
  }

  reconnect() {
    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
      console.error('Max reconnect attempts reached');
      return;
    }

    const delay = Math.pow(2, this.reconnectAttempts) * 1000;
    this.reconnectAttempts++;

    setTimeout(() => {
      console.log(`Reconnecting... (attempt ${this.reconnectAttempts})`);
      this.connect();
    }, delay);
  }

  handleMessage(message) {
    const handler = this.handlers[message.type];
    if (handler) {
      handler(message.data);
    }
  }

  on(type, handler) {
    this.handlers[type] = handler;
  }

  send(type, data) {
    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
      this.ws.send(JSON.stringify({ type, ...data }));
    }
  }

  subscribe(channelId) {
    this.send('subscribe', { channel_id: channelId });
  }

  unsubscribe(channelId) {
    this.send('unsubscribe', { channel_id: channelId });
  }

  disconnect() {
    if (this.ws) {
      this.ws.close();
    }
  }
}

export default EnotWebSocket;
                    

Использование

                        // app.js
import EnotAPI from './api.js';
import EnotWebSocket from './websocket.js';

// Регистрация
const api = new EnotAPI();
const { user, token } = await api.register('myusername', 'user@example.com', 'SecurePassword123!');

// Сохранить токен
localStorage.setItem('token', token);

// Создать API клиент с токеном
const authenticatedAPI = new EnotAPI(token);

// Получить серверы
const servers = await authenticatedAPI.getServers();
console.log('My servers:', servers);

// Подключиться к WebSocket
const ws = new EnotWebSocket(token);
ws.connect();

// Подписаться на новые сообщения
ws.on('message_new', (message) => {
  console.log('New message:', message);
  displayMessage(message);
});

// Подписаться на канал
ws.subscribe(123);

// Отправить сообщение
await authenticatedAPI.sendMessage(123, 'Hello, world!');
                    

React + TypeScript

Custom Hook для API

                        // useEnotAPI.ts
import { useState, useEffect } from 'react';

interface Message {
  id: number;
  content: string;
  user_id: number;
  channel_id: number;
  created_at: string;
}

export function useMessages(channelId: number, token: string) {
  const [messages, setMessages] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    async function fetchMessages() {
      try {
        const response = await fetch(
          `https://api.enot.space/api/channels/${channelId}/messages`,
          {
            headers: {
              'Authorization': `Bearer ${token}`
            }
          }
        );

        if (!response.ok) {
          throw new Error('Failed to fetch messages');
        }

        const data = await response.json();
        setMessages(data);
      } catch (err) {
        setError(err instanceof Error ? err.message : 'Unknown error');
      } finally {
        setLoading(false);
      }
    }

    fetchMessages();
  }, [channelId, token]);

  return { messages, loading, error };
}
                    

Компонент чата

// Chat.tsx
import React, { useState } from 'react';
import { useMessages } from './useEnotAPI';

interface ChatProps {
  channelId: number;
  token: string;
}

export function Chat({ channelId, token }: ChatProps) {
  const { messages, loading, error } = useMessages(channelId, token);
  const [newMessage, setNewMessage] = useState('');

  const sendMessage = async () => {
    const response = await fetch(
      `https://api.enot.space/api/channels/${channelId}/messages`,
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${token}`
        },
        body: JSON.stringify({ content: newMessage })
      }
    );

    if (response.ok) {
      setNewMessage('');
    }
  };

  if (loading) return Loading...;
  if (error) return Error: {error};

  return (
    
      
        {messages.map(msg => (
          
            User {msg.user_id}: {msg.content}
          
        ))}
      
      
         setNewMessage(e.target.value)}
          placeholder="Type a message..."
        />
        
      
    
  );
}

Python

Базовая настройка

                        # enot_api.py
import requests

class EnotAPI:
    def __init__(self, token=None):
        self.base_url = 'https://api.enot.space'
        self.token = token
        self.headers = {'Content-Type': 'application/json'}
        if token:
            self.headers['Authorization'] = f'Bearer {token}'

    def request(self, method, endpoint, data=None):
        url = f'{self.base_url}{endpoint}'
        response = requests.request(
            method,
            url,
            headers=self.headers,
            json=data
        )
        response.raise_for_status()
        return response.json()

    # Auth
    def register(self, username, email, password):
        return self.request('POST', '/api/auth/register', {
            'username': username,
            'email': email,
            'password': password
        })

    def login(self, username, password):
        return self.request('POST', '/api/auth/login', {
            'username': username,
            'password': password
        })

    # Servers
    def get_servers(self):
        return self.request('GET', '/api/servers')

    def create_server(self, name, description=''):
        return self.request('POST', '/api/servers', {
            'name': name,
            'description': description
        })

    # Messages
    def send_message(self, channel_id, content):
        return self.request('POST', f'/api/channels/{channel_id}/messages', {
            'content': content
        })
                    

Использование

                        # main.py
from enot_api import EnotAPI

# Регистрация
api = EnotAPI()
result = api.register('myusername', 'user@example.com', 'SecurePassword123!')
token = result['token']

# Создать API клиент с токеном
authenticated_api = EnotAPI(token)

# Получить серверы
servers = authenticated_api.get_servers()
print('My servers:', servers)

# Отправить сообщение
message = authenticated_api.send_message(123, 'Hello from Python!')
print('Sent message:', message)
                    

Дополнительные ресурсы

Полная документация API: API Reference

WebSocket документация: WebSocket

Примеры на GitHub: GitHub Repository

🦝 Enot Messenger

JavaScript / TypeScript

Базовая настройка

WebSocket подключение

Использование

React + TypeScript

Custom Hook для API

Компонент чата

Python

Базовая настройка

Использование

Дополнительные ресурсы