REST API - Code Examples

Practical code examples for integrating with the HelpDesk Pro REST API in various programming languages and frameworks.

📋 Table of Contents

Overview
JavaScript/TypeScript
PHP
Python
cURL
React Example
Vue.js Example
Node.js Example
Best Practices

Overview

This guide provides ready-to-use code examples for common API operations. All examples assume:

Base URL: https://your-domain.com/api/v1
Authentication token stored in a variable
JSON content type for requests

JavaScript/TypeScript

Basic API Client Class

javascript

class HelpDeskAPI {
  constructor(baseURL, token) {
    this.baseURL = baseURL;
    this.token = token;
  }

  async request(endpoint, options = {}) {
    const url = `${this.baseURL}${endpoint}`;
    const config = {
      ...options,
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
        'Authorization': `Bearer ${this.token}`,
        ...options.headers,
      },
    };

    const response = await fetch(url, config);
    const data = await response.json();

    if (!response.ok) {
      throw new Error(data.message || 'API request failed');
    }

    return data;
  }

  // Authentication
  async login(email, password) {
    const response = await fetch(`${this.baseURL}/auth/login`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
      },
      body: JSON.stringify({ email, password }),
    });

    const data = await response.json();
    if (data.success) {
      this.token = data.data.token;
    }
    return data;
  }

  // Tickets
  async getTickets(params = {}) {
    const queryString = new URLSearchParams(params).toString();
    return this.request(`/tickets?${queryString}`);
  }

  async getTicket(id) {
    return this.request(`/tickets/${id}`);
  }

  async createTicket(ticketData) {
    return this.request('/tickets', {
      method: 'POST',
      body: JSON.stringify(ticketData),
    });
  }

  async updateTicket(id, ticketData) {
    return this.request(`/tickets/${id}`, {
      method: 'PUT',
      body: JSON.stringify(ticketData),
    });
  }

  async deleteTicket(id) {
    return this.request(`/tickets/${id}`, {
      method: 'DELETE',
    });
  }

  async addComment(ticketId, comment) {
    return this.request(`/tickets/${ticketId}/comments`, {
      method: 'POST',
      body: JSON.stringify({ comment }),
    });
  }

  // Contacts
  async getContacts(params = {}) {
    const queryString = new URLSearchParams(params).toString();
    return this.request(`/contacts?${queryString}`);
  }

  async createContact(contactData) {
    return this.request('/contacts', {
      method: 'POST',
      body: JSON.stringify(contactData),
    });
  }

  // Dashboard
  async getDashboard() {
    return this.request('/dashboard');
  }

  async getMetrics() {
    return this.request('/dashboard/metrics');
  }
}

// Usage
const api = new HelpDeskAPI('https://your-domain.com/api/v1');

// Login first
await api.login('user@example.com', 'password');

// Get tickets
const tickets = await api.getTickets({ page: 1, per_page: 20 });

// Create a ticket
const newTicket = await api.createTicket({
  subject: 'API Test Ticket',
  details: 'This ticket was created via API',
  priority_id: 1,
  category_id: 1,
});

Using Axios

javascript

import axios from 'axios';

const api = axios.create({
  baseURL: 'https://your-domain.com/api/v1',
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json',
  },
});

// Add token to requests
api.interceptors.request.use((config) => {
  const token = localStorage.getItem('api_token');
  if (token) {
    config.headers.Authorization = `Bearer ${token}`;
  }
  return config;
});

// Handle errors
api.interceptors.response.use(
  (response) => response.data,
  (error) => {
    if (error.response?.status === 401) {
      // Token expired, redirect to login
      window.location.href = '/login';
    }
    return Promise.reject(error);
  }
);

// Usage
async function fetchTickets() {
  try {
    const response = await api.get('/tickets', {
      params: { page: 1, per_page: 20 },
    });
    console.log(response.data);
  } catch (error) {
    console.error('Error fetching tickets:', error);
  }
}

async function createTicket(ticketData) {
  try {
    const response = await api.post('/tickets', ticketData);
    return response.data;
  } catch (error) {
    if (error.response?.status === 422) {
      // Validation errors
      console.error('Validation errors:', error.response.data.errors);
    }
    throw error;
  }
}

PHP

Basic API Client Class

php

<?php

class HelpDeskAPI {
    private $baseURL;
    private $token;

    public function __construct($baseURL) {
        $this->baseURL = rtrim($baseURL, '/');
    }

    public function setToken($token) {
        $this->token = $token;
    }

    private function request($endpoint, $method = 'GET', $data = null) {
        $url = $this->baseURL . $endpoint;
        
        $ch = curl_init($url);
        
        $headers = [
            'Content-Type: application/json',
            'Accept: application/json',
        ];
        
        if ($this->token) {
            $headers[] = 'Authorization: Bearer ' . $this->token;
        }
        
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => $headers,
            CURLOPT_CUSTOMREQUEST => $method,
        ]);
        
        if ($data && in_array($method, ['POST', 'PUT', 'PATCH'])) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        
        $result = json_decode($response, true);
        
        if ($httpCode >= 400) {
            throw new Exception($result['message'] ?? 'API request failed', $httpCode);
        }
        
        return $result;
    }

    // Authentication
    public function login($email, $password) {
        $response = $this->request('/auth/login', 'POST', [
            'email' => $email,
            'password' => $password,
        ]);
        
        if ($response['success']) {
            $this->token = $response['data']['token'];
        }
        
        return $response;
    }

    // Tickets
    public function getTickets($params = []) {
        $queryString = http_build_query($params);
        return $this->request('/tickets?' . $queryString);
    }

    public function getTicket($id) {
        return $this->request("/tickets/{$id}");
    }

    public function createTicket($ticketData) {
        return $this->request('/tickets', 'POST', $ticketData);
    }

    public function updateTicket($id, $ticketData) {
        return $this->request("/tickets/{$id}", 'PUT', $ticketData);
    }

    public function deleteTicket($id) {
        return $this->request("/tickets/{$id}", 'DELETE');
    }

    public function addComment($ticketId, $comment) {
        return $this->request("/tickets/{$ticketId}/comments", 'POST', [
            'comment' => $comment,
        ]);
    }
}

// Usage
$api = new HelpDeskAPI('https://your-domain.com/api/v1');

// Login
$api->login('user@example.com', 'password');

// Get tickets
$tickets = $api->getTickets(['page' => 1, 'per_page' => 20]);

// Create ticket
$newTicket = $api->createTicket([
    'subject' => 'API Test Ticket',
    'details' => 'This ticket was created via API',
    'priority_id' => 1,
    'category_id' => 1,
]);

Using Laravel HTTP Client

php

<?php

use Illuminate\Support\Facades\Http;

class HelpDeskAPIService {
    private $baseURL;
    private $token;

    public function __construct() {
        $this->baseURL = config('services.helpdesk.api_url');
    }

    public function login($email, $password) {
        $response = Http::post("{$this->baseURL}/auth/login", [
            'email' => $email,
            'password' => $password,
        ]);

        if ($response->successful()) {
            $data = $response->json();
            $this->token = $data['data']['token'];
            return $data;
        }

        throw new Exception('Login failed');
    }

    public function getTickets($params = []) {
        return Http::withToken($this->token)
            ->get("{$this->baseURL}/tickets", $params)
            ->json();
    }

    public function createTicket($ticketData) {
        return Http::withToken($this->token)
            ->post("{$this->baseURL}/tickets", $ticketData)
            ->json();
    }
}

Python

Basic API Client Class

python

import requests
from typing import Optional, Dict, Any

class HelpDeskAPI:
    def __init__(self, base_url: str):
        self.base_url = base_url.rstrip('/')
        self.token: Optional[str] = None

    def _request(self, endpoint: str, method: str = 'GET', data: Optional[Dict] = None) -> Dict[str, Any]:
        url = f"{self.base_url}{endpoint}"
        headers = {
            'Content-Type': 'application/json',
            'Accept': 'application/json',
        }
        
        if self.token:
            headers['Authorization'] = f'Bearer {self.token}'
        
        response = requests.request(
            method=method,
            url=url,
            headers=headers,
            json=data
        )
        
        response.raise_for_status()
        return response.json()

    def login(self, email: str, password: str) -> Dict[str, Any]:
        response = self._request('/auth/login', 'POST', {
            'email': email,
            'password': password,
        })
        
        if response.get('success'):
            self.token = response['data']['token']
        
        return response

    def get_tickets(self, params: Optional[Dict] = None) -> Dict[str, Any]:
        query_string = '&'.join([f"{k}={v}" for k, v in (params or {}).items()])
        endpoint = f'/tickets?{query_string}' if query_string else '/tickets'
        return self._request(endpoint)

    def get_ticket(self, ticket_id: int) -> Dict[str, Any]:
        return self._request(f'/tickets/{ticket_id}')

    def create_ticket(self, ticket_data: Dict[str, Any]) -> Dict[str, Any]:
        return self._request('/tickets', 'POST', ticket_data)

    def update_ticket(self, ticket_id: int, ticket_data: Dict[str, Any]) -> Dict[str, Any]:
        return self._request(f'/tickets/{ticket_id}', 'PUT', ticket_data)

    def delete_ticket(self, ticket_id: int) -> Dict[str, Any]:
        return self._request(f'/tickets/{ticket_id}', 'DELETE')

    def add_comment(self, ticket_id: int, comment: str) -> Dict[str, Any]:
        return self._request(f'/tickets/{ticket_id}/comments', 'POST', {
            'comment': comment,
        })

# Usage
api = HelpDeskAPI('https://your-domain.com/api/v1')

# Login
api.login('user@example.com', 'password')

# Get tickets
tickets = api.get_tickets({'page': 1, 'per_page': 20})

# Create ticket
new_ticket = api.create_ticket({
    'subject': 'API Test Ticket',
    'details': 'This ticket was created via API',
    'priority_id': 1,
    'category_id': 1,
})

cURL

Authentication

bash

# Login
curl -X POST https://your-domain.com/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "email": "user@example.com",
    "password": "password"
  }'

Tickets

bash

# Get all tickets
curl -X GET https://your-domain.com/api/v1/tickets \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Accept: application/json"

# Get tickets with filters
curl -X GET "https://your-domain.com/api/v1/tickets?page=1&per_page=20&status_id=1" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Accept: application/json"

# Get single ticket
curl -X GET https://your-domain.com/api/v1/tickets/1 \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Accept: application/json"

# Create ticket
curl -X POST https://your-domain.com/api/v1/tickets \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "subject": "New Support Request",
    "details": "I need help with...",
    "priority_id": 1,
    "category_id": 1
  }'

# Update ticket
curl -X PUT https://your-domain.com/api/v1/tickets/1 \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "status_id": 2,
    "assigned_to": 3
  }'

# Add comment
curl -X POST https://your-domain.com/api/v1/tickets/1/comments \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "comment": "This is a comment"
  }'

# Delete ticket
curl -X DELETE https://your-domain.com/api/v1/tickets/1 \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Accept: application/json"

React Example

jsx

import React, { useState, useEffect } from 'react';
import axios from 'axios';

const API_BASE_URL = 'https://your-domain.com/api/v1';

function TicketList() {
  const [tickets, setTickets] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    fetchTickets();
  }, []);

  const fetchTickets = async () => {
    try {
      const token = localStorage.getItem('api_token');
      const response = await axios.get(`${API_BASE_URL}/tickets`, {
        headers: {
          'Authorization': `Bearer ${token}`,
          'Accept': 'application/json',
        },
        params: {
          page: 1,
          per_page: 20,
        },
      });

      if (response.data.success) {
        setTickets(response.data.data);
      }
    } catch (err) {
      setError(err.response?.data?.message || 'Failed to fetch tickets');
    } finally {
      setLoading(false);
    }
  };

  const createTicket = async (ticketData) => {
    try {
      const token = localStorage.getItem('api_token');
      const response = await axios.post(
        `${API_BASE_URL}/tickets`,
        ticketData,
        {
          headers: {
            'Authorization': `Bearer ${token}`,
            'Content-Type': 'application/json',
            'Accept': 'application/json',
          },
        }
      );

      if (response.data.success) {
        // Refresh ticket list
        fetchTickets();
        return response.data.data;
      }
    } catch (err) {
      if (err.response?.status === 422) {
        // Handle validation errors
        console.error('Validation errors:', err.response.data.errors);
      }
      throw err;
    }
  };

  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error}</div>;

  return (
    <div>
      <h1>Tickets</h1>
      <ul>
        {tickets.map(ticket => (
          <li key={ticket.id}>
            <strong>{ticket.subject}</strong> - {ticket.status.name}
          </li>
        ))}
      </ul>
    </div>
  );
}

export default TicketList;

Vue.js Example

vue

<template>
  <div>
    <h1>Tickets</h1>
    <div v-if="loading">Loading...</div>
    <div v-else-if="error">Error: {{ error }}</div>
    <ul v-else>
      <li v-for="ticket in tickets" :key="ticket.id">
        <strong>{{ ticket.subject }}</strong> - {{ ticket.status.name }}
      </li>
    </ul>
  </div>
</template>

<script>
import axios from 'axios';

export default {
  data() {
    return {
      tickets: [],
      loading: true,
      error: null,
      apiBaseURL: 'https://your-domain.com/api/v1',
    };
  },
  mounted() {
    this.fetchTickets();
  },
  methods: {
    async fetchTickets() {
      try {
        const token = localStorage.getItem('api_token');
        const response = await axios.get(`${this.apiBaseURL}/tickets`, {
          headers: {
            'Authorization': `Bearer ${token}`,
            'Accept': 'application/json',
          },
          params: {
            page: 1,
            per_page: 20,
          },
        });

        if (response.data.success) {
          this.tickets = response.data.data;
        }
      } catch (err) {
        this.error = err.response?.data?.message || 'Failed to fetch tickets';
      } finally {
        this.loading = false;
      }
    },
    async createTicket(ticketData) {
      try {
        const token = localStorage.getItem('api_token');
        const response = await axios.post(
          `${this.apiBaseURL}/tickets`,
          ticketData,
          {
            headers: {
              'Authorization': `Bearer ${token}`,
              'Content-Type': 'application/json',
              'Accept': 'application/json',
            },
          }
        );

        if (response.data.success) {
          this.fetchTickets();
          return response.data.data;
        }
      } catch (err) {
        if (err.response?.status === 422) {
          console.error('Validation errors:', err.response.data.errors);
        }
        throw err;
      }
    },
  },
};
</script>

Node.js Example

javascript

const axios = require('axios');

class HelpDeskAPI {
  constructor(baseURL) {
    this.baseURL = baseURL;
    this.token = null;
  }

  async login(email, password) {
    const response = await axios.post(`${this.baseURL}/auth/login`, {
      email,
      password,
    });

    if (response.data.success) {
      this.token = response.data.data.token;
    }

    return response.data;
  }

  async getTickets(params = {}) {
    const response = await axios.get(`${this.baseURL}/tickets`, {
      headers: {
        'Authorization': `Bearer ${this.token}`,
        'Accept': 'application/json',
      },
      params,
    });

    return response.data;
  }

  async createTicket(ticketData) {
    const response = await axios.post(
      `${this.baseURL}/tickets`,
      ticketData,
      {
        headers: {
          'Authorization': `Bearer ${this.token}`,
          'Content-Type': 'application/json',
          'Accept': 'application/json',
        },
      }
    );

    return response.data;
  }
}

// Usage
(async () => {
  const api = new HelpDeskAPI('https://your-domain.com/api/v1');

  // Login
  await api.login('user@example.com', 'password');

  // Get tickets
  const tickets = await api.getTickets({ page: 1, per_page: 20 });
  console.log(tickets);

  // Create ticket
  const newTicket = await api.createTicket({
    subject: 'API Test Ticket',
    details: 'This ticket was created via API',
    priority_id: 1,
    category_id: 1,
  });
  console.log(newTicket);
})();

Best Practices

1. Error Handling

Always implement proper error handling:

javascript

try {
  const response = await api.getTickets();
} catch (error) {
  if (error.response) {
    // Server responded with error
    switch (error.response.status) {
      case 401:
        // Unauthorized - redirect to login
        break;
      case 403:
        // Forbidden - show permission error
        break;
      case 422:
        // Validation error - show field errors
        break;
      case 429:
        // Rate limited - wait and retry
        break;
      default:
        // Other error
    }
  } else {
    // Network error
  }
}

2. Token Management

Store tokens securely and handle expiration:

javascript

// Store token
localStorage.setItem('api_token', token);

// Check token before requests
const token = localStorage.getItem('api_token');
if (!token) {
  // Redirect to login
}

// Handle 401 responses
if (response.status === 401) {
  localStorage.removeItem('api_token');
  // Redirect to login
}

3. Request Retry

Implement retry logic for failed requests:

javascript

async function requestWithRetry(url, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fetch(url, options);
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
    }
  }
}

4. Rate Limiting

Respect rate limits and implement throttling:

javascript

class RateLimiter {
  constructor(maxRequests, windowMs) {
    this.maxRequests = maxRequests;
    this.windowMs = windowMs;
    this.requests = [];
  }

  async wait() {
    const now = Date.now();
    this.requests = this.requests.filter(time => now - time < this.windowMs);

    if (this.requests.length >= this.maxRequests) {
      const oldestRequest = this.requests[0];
      const waitTime = this.windowMs - (now - oldestRequest);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }

    this.requests.push(Date.now());
  }
}

const limiter = new RateLimiter(60, 60000); // 60 requests per minute

async function makeRequest() {
  await limiter.wait();
  // Make API request
}

Next Steps

API Endpoints - Complete endpoint reference
Error Handling - Understanding API errors
Authentication - Detailed auth guide

For more examples and use cases, check our GitHub repository or contact support.

REST API - Code Examples ​

📋 Table of Contents ​

Overview ​

JavaScript/TypeScript ​

Basic API Client Class ​

Using Axios ​

PHP ​

Basic API Client Class ​

Using Laravel HTTP Client ​

Python ​

Basic API Client Class ​

cURL ​

Authentication ​

Tickets ​

React Example ​

Vue.js Example ​

Node.js Example ​

Best Practices ​

1. Error Handling ​

2. Token Management ​

3. Request Retry ​

4. Rate Limiting ​

Next Steps ​

REST API - Code Examples

📋 Table of Contents

Overview

JavaScript/TypeScript

Basic API Client Class

Using Axios

PHP

Basic API Client Class

Using Laravel HTTP Client

Python

Basic API Client Class

cURL

Authentication

Tickets

React Example

Vue.js Example

Node.js Example

Best Practices

1. Error Handling

2. Token Management

3. Request Retry

4. Rate Limiting

Next Steps