ZUP API Documentation

// Client complet pentru API-ul ZUP - JavaScript cu token management complet
class ZupAPIClient {
  constructor(clientId, clientSecret, accessToken = null, refreshToken = null) {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.accessToken = accessToken;
    this.refreshToken = refreshToken;
    this.baseUrl = 'https://zup.ro/zapi/v1';
  }
  
  // Obține token-ul inițial din codul de autorizare
  async getInitialToken(authorizationCode, redirectUri) {
    try {
      const response = await fetch(`${this.baseUrl}/oauth/token`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
        },
        body: new URLSearchParams({
          grant_type: 'authorization_code',
          code: authorizationCode,
          client_id: this.clientId,
          client_secret: this.clientSecret,
          redirect_uri: redirectUri
        })
      });
      
      if (!response.ok) {
        throw new Error('Failed to get initial token');
      }
      
      const tokens = await response.json();
      this.accessToken = tokens.access_token;
      this.refreshToken = tokens.refresh_token;
      
      // Salvează token-urile pentru utilizare ulterioară
      localStorage.setItem('zup_access_token', tokens.access_token);
      localStorage.setItem('zup_refresh_token', tokens.refresh_token);
      
      return tokens;
    } catch (error) {
      console.error('Failed to get initial token:', error);
      throw error;
    }
  }
  
  // Actualizează token-ul folosind refresh_token
  async refreshAccessToken() {
    try {
      const response = await fetch(`${this.baseUrl}/oauth/token`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
        },
        body: new URLSearchParams({
          grant_type: 'refresh_token',
          refresh_token: this.refreshToken,
          client_id: this.clientId,
          client_secret: this.clientSecret
        })
      });
      
      if (!response.ok) {
        throw new Error('Token refresh failed');
      }
      
      const tokens = await response.json();
      this.accessToken = tokens.access_token;
      
      // Salvează noul token pentru utilizare ulterioară
      localStorage.setItem('zup_access_token', tokens.access_token);
      if (tokens.refresh_token) {
        this.refreshToken = tokens.refresh_token;
        localStorage.setItem('zup_refresh_token', tokens.refresh_token);
      }
      
      return tokens.access_token;
    } catch (error) {
      console.error('Failed to refresh token:', error);
      throw error;
    }
  }
  
  async makeRequest(endpoint, method = 'GET', data = null, retryCount = 0) {
    const config = {
      method: method,
      headers: {
        'Authorization': `Bearer ${this.accessToken}`,
        'Content-Type': 'application/json',
      }
    };
    
    if (data && method !== 'GET') {
      config.body = JSON.stringify(data);
    }
    
    try {
      const response = await fetch(`${this.baseUrl}${endpoint}`, config);
      
      // Dacă tokenul a expirat (401 Unauthorized), încearcă să-l reîmprospătezi
      if (response.status === 401 && retryCount === 0) {
        console.log('Token expirat, încerc să-l reîmprospătez...');
        await this.refreshAccessToken();
        // Reîncearcă request-ul cu noul token (doar o dată)
        return await this.makeRequest(endpoint, method, data, 1);
      }
      
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('API Request failed:', error);
      throw error;
    }
  }
  
  // Exemple de endpoint-uri
  async getCategories() {
    return await this.makeRequest('/categories');
  }
  
  async getCounties() {
    return await this.makeRequest('/locations?counties_only=true');
  }
  
  async getLocalities(countyName = null, search = null) {
    const params = new URLSearchParams();
    if (countyName) params.append('county_name', countyName);
    if (search) params.append('search', search);
    const queryString = params.toString() ? '?' + params.toString() : '';
    return await this.makeRequest('/locations' + queryString);
  }
  
  async getAllLocations() {
    return await this.makeRequest('/locations');
  }
  
  async getMyAds() {
    return await this.makeRequest('/anunturi');
  }

  async getPromotedAds(limit = 12) {
    return await this.makeRequest(`/anunturi/promoted?limit=${limit}`);
  }

  async createAd(adData) {
    return await this.makeRequest('/anunturi', 'POST', adData);
  }
  
  async createAdsBatch(adsArray) {
    return await this.makeRequest('/anunturi/batch', 'POST', adsArray);
  }
  
  async updateAd(adId, adData) {
    return await this.makeRequest(`/anunturi/${adId}`, 'PUT', adData);
  }
  
  async activateAd(adId) {
    return await this.makeRequest(`/anunturi/${adId}/command`, 'POST', { command: 'activate' });
  }
  
  async deactivateAd(adId) {
    return await this.makeRequest(`/anunturi/${adId}/command`, 'POST', { command: 'deactivate' });
  }
}

// Exemplu de utilizare completă cu token management complet
const clientId = 'your-client-id';
const clientSecret = 'your-client-secret';

// Scenario 1: Obținerea primului token din authorization code
async function initializeWithAuthCode() {
  const zupClient = new ZupAPIClient(clientId, clientSecret);
  
  // Obține codul de autorizare din URL (după redirect de la OAuth)
  const urlParams = new URLSearchParams(window.location.search);
  const authorizationCode = urlParams.get('code');
  const redirectUri = 'https://aplicatia-ta.com/oauth/callback';
  
  if (authorizationCode) {
    try {
      // Obține primul token
      const tokens = await zupClient.getInitialToken(authorizationCode, redirectUri);
      console.log('Token-uri obținute cu succes:', tokens);
      
      // Acum poți folosi API-ul
      const categories = await zupClient.getCategories();
      console.log('Categorii disponibile:', categories);
      
      // Obține județele
      const counties = await zupClient.getCounties();
      console.log('Județe disponibile:', counties);
      
      // Obține localitățile din București
      const localities = await zupClient.getLocalities('București', null);
      console.log('Localități din București:', localities);
    } catch (error) {
      console.error('Eroare la obținerea token-ului:', error);
    }
  }
}

// Scenario 2: Utilizarea cu token-uri existente
async function useExistingTokens() {
  const existingAccessToken = localStorage.getItem('zup_access_token');
  const existingRefreshToken = localStorage.getItem('zup_refresh_token');
  
  const zupClient = new ZupAPIClient(clientId, clientSecret, existingAccessToken, existingRefreshToken);
  
  try {
    // API calls - token-ul va fi refresh-at automat dacă expiră
    const categories = await zupClient.getCategories();
    console.log('Categorii disponibile:', categories);
    
    // Creează un anunț nou cu fotografii din URL-uri
    const newAd = {
      name: 'iPhone 15 Pro',
      description: 'Telefon în stare excelentă',
      category_id: 3099,  // Categoria finală - sistemul construiește automat ierarhia completă
      county: 'București',
      locality: 'Sectorul 1',
      photos_urls: [
        'https://example.com/iphone15-front.jpg',
        'https://example.com/iphone15-back.jpg'
      ]
    };

    // Creează un anunț promovat (evidențiat)
    const promotedAd = {
      name: 'iPhone 15 Pro - OFERTĂ SPECIALĂ',
      description: 'Telefon în stare excelentă, preț negociabil',
      category_id: 3099,  // Categoria finală - ierarhia se construiește automat
      county: 'București',
      locality: 'Sectorul 1',
      is_featured: true,  // Marchează anunțul ca promovat
      photos_urls: [
        'https://example.com/iphone15-front.jpg',
        'https://example.com/iphone15-back.jpg'
      ]
    };
    
    const createdAd = await zupClient.createAd(newAd);
    console.log('Anunț creat:', createdAd);

    // Obține anunțurile promovate
    const promotedAds = await zupClient.getPromotedAds(15);
    console.log('Anunțuri promovate:', promotedAds);

    // Creează un anunț promovat direct
    const createdPromotedAd = await zupClient.createAd(promotedAd);
    console.log('Anunț promovat creat:', createdPromotedAd);

    // Actualizează un anunț existent pentru a-l promova
    const updatedAd = await zupClient.updateAd(createdAd.id, { is_featured: true });
    console.log('Anunț promovat:', updatedAd);

    // Creează mai multe anunțuri într-o cerere (batch)
    const multiplAds = [
      {
        name: 'Samsung Galaxy S24',
        description: 'Nou, nout',
        category_id: 3099,  // Categoria finală
        county: 'Cluj',
        locality: 'Cluj-Napoca',
        photos_urls: ['https://example.com/samsung-s24.jpg']
      },
      {
        name: 'MacBook Pro 16"',
        description: 'Pentru dezvoltatori',
        category_id: 920,  // Categoria finală
        county: 'Iași',
        locality: 'Iași',
        photos_urls: ['https://example.com/macbook-pro.jpg']
      }
    ];
    
    const batchResult = await zupClient.createAdsBatch(multiplAds);
    console.log('Rezultat batch:', batchResult);
    console.log(`Anunțuri create cu succes: ${batchResult.success_count}`);
    console.log(`Anunțuri cu erori: ${batchResult.error_count}`);
  } catch (error) {
    console.error('Eroare în utilizarea API-ului:', error);
  }
}

// Utilizează funcția potrivită în funcție de situație
if (new URLSearchParams(window.location.search).get('code')) {
  initializeWithAuthCode();
} else {
  useExistingTokens();
}