Примеры кода

Готовые примеры интеграции на популярных языках программирования. Копируйте и адаптируйте под свои нужды.

Календарь для психологов

1. Получение свободных слотов

JavaScript (fetch)

async function getAvailableSlots(date) {
  const API_KEY = process.env.VIALINE_API_KEY;
  const API_URL = 'https://api.vialine.ru';

  try {
    const response = await fetch(
      `${API_URL}/api/v1/slots?date=${date}`,
      {
        method: 'GET',
        headers: {
          'x-api-key': API_KEY,
          'Content-Type': 'application/json'
        }
      }
    );

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    
    if (data.success) {
      console.log('Доступные слоты:', data.data.slots);
      return data.data.slots.filter(slot => slot.available);
    } else {
      console.error('Ошибка API:', data.error);
      return [];
    }
  } catch (error) {
    console.error('Ошибка запроса:', error);
    throw error;
  }
}

// Использование
getAvailableSlots('2024-10-20')
  .then(slots => {
    slots.forEach(slot => {
      console.log(`Свободно: ${slot.startTime} - ${slot.endTime}`);
    });
  });

Node.js (axios)

const axios = require('axios');

async function getAvailableSlots(date) {
  const config = {
    method: 'get',
    url: `https://api.vialine.ru/api/v1/slots?date=${date}`,
    headers: {
      'x-api-key': process.env.VIALINE_API_KEY,
      'Content-Type': 'application/json'
    }
  };

  try {
    const response = await axios(config);
    
    if (response.data.success) {
      return response.data.data.slots.filter(
        slot => slot.available
      );
    }
    
    throw new Error(response.data.error?.message || 'Unknown error');
  } catch (error) {
    if (error.response) {
      // Ошибка от сервера
      console.error('Ошибка API:', error.response.data);
    } else if (error.request) {
      // Запрос был отправлен, но ответа нет
      console.error('Нет ответа от сервера');
    } else {
      console.error('Ошибка:', error.message);
    }
    throw error;
  }
}

module.exports = { getAvailableSlots };

Python

import os
import requests
from datetime import datetime

def get_available_slots(date):
    """
    Получение свободных слотов на указанную дату
    
    Args:
        date (str): Дата в формате 'YYYY-MM-DD'
    
    Returns:
        list: Список доступных слотов
    """
    api_key = os.environ.get('VIALINE_API_KEY')
    api_url = 'https://api.vialine.ru'
    
    headers = {
        'x-api-key': api_key,
        'Content-Type': 'application/json'
    }
    
    try:
        response = requests.get(
            f'{api_url}/api/v1/slots',
            headers=headers,
            params={'date': date}
        )
        
        response.raise_for_status()
        data = response.json()
        
        if data.get('success'):
            slots = data.get('data', {}).get('slots', [])
            available = [s for s in slots if s.get('available')]
            return available
        else:
            error = data.get('error', {})
            raise Exception(f"API Error: {error.get('message')}")
            
    except requests.exceptions.RequestException as e:
        print(f"Ошибка запроса: {e}")
        raise

# Использование
if __name__ == '__main__':
    slots = get_available_slots('2024-10-20')
    for slot in slots:
        print(f"Свободно: {slot['startTime']} - {slot['endTime']}")

2. Создание записи

JavaScript (fetch)

async function createAppointment(appointmentData) {
  const API_KEY = process.env.VIALINE_API_KEY;
  const API_URL = 'https://api.vialine.ru';

  try {
    const response = await fetch(
      `${API_URL}/api/v1/appointments`,
      {
        method: 'POST',
        headers: {
          'x-api-key': API_KEY,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(appointmentData)
      }
    );

    const data = await response.json();

    if (response.ok && data.success) {
      console.log('Запись успешно создана:', data.data);
      return data.data;
    } else {
      // Обработка ошибок
      if (response.status === 409) {
        throw new Error('Этот слот уже занят');
      } else if (response.status === 400) {
        throw new Error('Неверные данные: ' + data.error?.message);
      } else {
        throw new Error(data.error?.message || 'Неизвестная ошибка');
      }
    }
  } catch (error) {
    console.error('Ошибка при создании записи:', error);
    throw error;
  }
}

// Пример использования
const appointmentData = {
  clientData: {
    name: 'Иван Иванов',
    phone: '+79991234567',
    email: 'ivan@example.com'
  },
  startTime: '2024-10-20T09:00:00Z',
  endTime: '2024-10-20T10:00:00Z'
};

createAppointment(appointmentData)
  .then(appointment => {
    console.log('ID записи:', appointment.id);
    console.log('Статус:', appointment.status);
  })
  .catch(error => {
    console.error('Ошибка:', error.message);
  });

Python

import os
import requests

def create_appointment(client_name, client_phone, start_time, end_time, 
                      client_email=None):
    """
    Создание записи на приём
    
    Args:
        client_name (str): Имя клиента
        client_phone (str): Телефон клиента
        start_time (str): Время начала в ISO формате
        end_time (str): Время окончания в ISO формате
        client_email (str, optional): Email клиента
    
    Returns:
        dict: Данные созданной записи
    """
    api_key = os.environ.get('VIALINE_API_KEY')
    api_url = 'https://api.vialine.ru'
    
    headers = {
        'x-api-key': api_key,
        'Content-Type': 'application/json'
    }
    
    payload = {
        'clientData': {
            'name': client_name,
            'phone': client_phone
        },
        'startTime': start_time,
        'endTime': end_time
    }
    
    if client_email:
        payload['clientData']['email'] = client_email
    
    try:
        response = requests.post(
            f'{api_url}/api/v1/appointments',
            headers=headers,
            json=payload
        )
        
        data = response.json()
        
        if response.status_code == 201 and data.get('success'):
            print(f"Запись создана! ID: {data['data']['id']}")
            return data['data']
        elif response.status_code == 409:
            raise Exception("Слот уже занят")
        elif response.status_code == 400:
            raise Exception(f"Неверные данные: {data.get('error', {}).get('message')}")
        else:
            raise Exception(f"Ошибка API: {data.get('error', {}).get('message')}")
            
    except requests.exceptions.RequestException as e:
        print(f"Ошибка запроса: {e}")
        raise

# Использование
if __name__ == '__main__':
    appointment = create_appointment(
        client_name='Иван Иванов',
        client_phone='+79991234567',
        client_email='ivan@example.com',
        start_time='2024-10-20T09:00:00Z',
        end_time='2024-10-20T10:00:00Z'
    )
    
    print(f"Статус: {appointment['status']}")
    print(f"Время: {appointment['startTime']} - {appointment['endTime']}")

3. React компонент с выбором слота

import { useState, useEffect } from 'react';

function AppointmentBooking() {
  const [selectedDate, setSelectedDate] = useState('2024-10-20');
  const [slots, setSlots] = useState([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);
  
  const [formData, setFormData] = useState({
    name: '',
    phone: '',
    email: ''
  });

  // Загрузка слотов
  useEffect(() => {
    async function fetchSlots() {
      setLoading(true);
      setError(null);
      
      try {
        const response = await fetch(
          `/api/proxy/slots?date=${selectedDate}`
        );
        
        const data = await response.json();
        
        if (data.success) {
          setSlots(data.data.slots.filter(s => s.available));
        } else {
          setError('Ошибка загрузки слотов');
        }
      } catch (err) {
        setError('Ошибка сети');
      } finally {
        setLoading(false);
      }
    }
    
    fetchSlots();
  }, [selectedDate]);

  const handleSubmit = async (e, slot) => {
    e.preventDefault();
    
    try {
      const response = await fetch('/api/proxy/appointments', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          clientData: formData,
          startTime: slot.startTime,
          endTime: slot.endTime
        })
      });
      
      const data = await response.json();
      
      if (data.success) {
        alert('Запись успешно создана!');
        // Обновить список слотов
        setSlots(slots.filter(s => s !== slot));
      } else {
        alert('Ошибка: ' + data.error?.message);
      }
    } catch (err) {
      alert('Ошибка при создании записи');
    }
  };

  return (
    <div className="appointment-booking">
      <h2>Запись на приём</h2>
      
      <input
        type="date"
        value={selectedDate}
        onChange={(e) => setSelectedDate(e.target.value)}
      />
      
      {loading && <p>Загрузка слотов...</p>}
      {error && <p className="error">{error}</p>}
      
      <div className="slots-list">
        {slots.map((slot) => (
          <div key={slot.startTime} className="slot-card">
            <h3>{new Date(slot.startTime).toLocaleTimeString('ru-RU')}</h3>
            
            <form onSubmit={(e) => handleSubmit(e, slot)}>
              <input
                type="text"
                placeholder="Ваше имя"
                value={formData.name}
                onChange={(e) => setFormData({...formData, name: e.target.value})}
                required
              />
              
              <input
                type="tel"
                placeholder="Телефон"
                value={formData.phone}
                onChange={(e) => setFormData({...formData, phone: e.target.value})}
                required
              />
              
              <input
                type="email"
                placeholder="Email (опционально)"
                value={formData.email}
                onChange={(e) => setFormData({...formData, email: e.target.value})}
              />
              
              <button type="submit">Записаться</button>
            </form>
          </div>
        ))}
      </div>
    </div>
  );
}

export default AppointmentBooking;

Лазерная резка DXF

1. Загрузка DXF-файла и создание заказа

JavaScript (FormData)

async function createLaserOrder(file, orderData) {
  const API_KEY = process.env.VIALINE_API_KEY;
  const API_URL = 'https://api.vialine.ru';
  
  const formData = new FormData();
  formData.append('dxfFile', file);
  formData.append('material', orderData.material);
  formData.append('thickness', orderData.thickness);
  formData.append('quantity', orderData.quantity);
  formData.append('clientEmail', orderData.clientEmail);

  try {
    const response = await fetch(
      `${API_URL}/api/v1/laser-dxf/orders`,
      {
        method: 'POST',
        headers: {
          'x-api-key': API_KEY
          // НЕ добавляйте Content-Type для FormData
        },
        body: formData
      }
    );

    const data = await response.json();

    if (response.ok && data.success) {
      console.log('Заказ создан:', data.data);
      return data.data;
    } else {
      throw new Error(data.error?.message || 'Ошибка создания заказа');
    }
  } catch (error) {
    console.error('Ошибка:', error);
    throw error;
  }
}

// Использование с file input
const fileInput = document.getElementById('dxf-file');
const file = fileInput.files[0];

const orderData = {
  material: 'steel',
  thickness: 3.0,
  quantity: 5,
  clientEmail: 'client@example.com'
};

createLaserOrder(file, orderData)
  .then(order => {
    console.log('ID заказа:', order.orderId);
    console.log('Стоимость:', order.estimatedCost);
    console.log('Время изготовления:', order.estimatedTime, 'минут');
  });

Python (requests)

import os
import requests

def create_laser_order(dxf_file_path, material, thickness, 
                       quantity, client_email):
    """
    Создание заказа на лазерную резку
    
    Args:
        dxf_file_path (str): Путь к DXF-файлу
        material (str): Материал (steel, aluminum, brass)
        thickness (float): Толщина материала в мм
        quantity (int): Количество деталей
        client_email (str): Email для уведомлений
    
    Returns:
        dict: Данные созданного заказа
    """
    api_key = os.environ.get('VIALINE_API_KEY')
    api_url = 'https://api.vialine.ru'
    
    headers = {
        'x-api-key': api_key
    }
    
    with open(dxf_file_path, 'rb') as f:
        files = {
            'dxfFile': (os.path.basename(dxf_file_path), f, 'application/dxf')
        }
        
        data = {
            'material': material,
            'thickness': thickness,
            'quantity': quantity,
            'clientEmail': client_email
        }
        
        try:
            response = requests.post(
                f'{api_url}/api/v1/laser-dxf/orders',
                headers=headers,
                files=files,
                data=data
            )
            
            result = response.json()
            
            if response.status_code == 201 and result.get('success'):
                order = result['data']
                print(f"Заказ создан! ID: {order['orderId']}")
                print(f"Стоимость: {order['estimatedCost']} руб.")
                print(f"Время: {order['estimatedTime']} мин.")
                return order
            else:
                error = result.get('error', {})
                raise Exception(f"Ошибка API: {error.get('message')}")
                
        except requests.exceptions.RequestException as e:
            print(f"Ошибка запроса: {e}")
            raise

# Использование
if __name__ == '__main__':
    order = create_laser_order(
        dxf_file_path='./parts/bracket.dxf',
        material='steel',
        thickness=3.0,
        quantity=5,
        client_email='client@example.com'
    )

2. Проверка статуса заказа

JavaScript

async function getOrderStatus(orderId) {
  const API_KEY = process.env.VIALINE_API_KEY;
  const API_URL = 'https://api.vialine.ru';

  try {
    const response = await fetch(
      `${API_URL}/api/v1/laser-dxf/orders/${orderId}`,
      {
        method: 'GET',
        headers: {
          'x-api-key': API_KEY,
          'Content-Type': 'application/json'
        }
      }
    );

    const data = await response.json();

    if (response.ok && data.success) {
      const order = data.data;
      
      console.log('Статус заказа:', order.status);
      console.log('История:', order.statusHistory);
      
      return order;
    } else {
      throw new Error(data.error?.message || 'Ошибка получения статуса');
    }
  } catch (error) {
    console.error('Ошибка:', error);
    throw error;
  }
}

// Использование
getOrderStatus('dxf_550e8400e29b41d4')
  .then(order => {
    switch(order.status) {
      case 'PENDING':
        console.log('Заказ принят в обработку');
        break;
      case 'PROCESSING':
        console.log('Заказ в производстве');
        break;
      case 'READY':
        console.log('Заказ готов к выдаче');
        break;
      case 'DELIVERED':
        console.log('Заказ доставлен');
        break;
    }
  });

Python

import os
import requests
from datetime import datetime

def get_order_status(order_id):
    """Получение статуса заказа"""
    api_key = os.environ.get('VIALINE_API_KEY')
    api_url = 'https://api.vialine.ru'
    
    headers = {
        'x-api-key': api_key,
        'Content-Type': 'application/json'
    }
    
    try:
        response = requests.get(
            f'{api_url}/api/v1/laser-dxf/orders/{order_id}',
            headers=headers
        )
        
        data = response.json()
        
        if response.ok and data.get('success'):
            order = data['data']
            
            print(f"Заказ {order['orderId']}")
            print(f"Статус: {order['status']}")
            print(f"Материал: {order['material']}, {order['thickness']}мм")
            print(f"Количество: {order['quantity']}")
            print(f"Стоимость: {order['estimatedCost']} руб.")
            
            # История статусов
            print("
История изменений:")
            for item in order.get('statusHistory', []):
                timestamp = datetime.fromisoformat(
                    item['timestamp'].replace('Z', '+00:00')
                )
                print(f"  {item['status']}: {timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
            
            return order
        else:
            error = data.get('error', {})
            raise Exception(f"Ошибка API: {error.get('message')}")
            
    except requests.exceptions.RequestException as e:
        print(f"Ошибка запроса: {e}")
        raise

# Использование
if __name__ == '__main__':
    order = get_order_status('dxf_550e8400e29b41d4')

Лучшие практики

Обработка ошибок

Всегда обрабатывайте возможные ошибки и предоставляйте понятные сообщения пользователям

• Используйте try-catch блоки
• Проверяйте статус ответа
• Логируйте ошибки
• Показывайте дружественные сообщения

Rate Limiting

Учитывайте лимиты запросов и реализуйте retry логику

• Используйте экспоненциальную задержку
• Следите за заголовком retryAfter
• Кешируйте данные когда возможно
• Батчируйте запросы

Безопасность

Защищайте API-ключи и данные пользователей

• Не раскрывайте ключи в коде
• Используйте переменные окружения
• Проксируйте запросы через бэкенд
• Валидируйте входные данные

Тестирование

Тестируйте интеграцию перед продакшеном

• Используйте тестовые ключи
• Проверяйте edge cases
• Тестируйте обработку ошибок
• Мониторьте production использование