Atlas API API Reference

using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

public class AtlasApiClient
{
    private readonly HttpClient _httpClient;
    private readonly string _publicKey;
    private readonly string _secretKey;

    public AtlasApiClient(string publicKey, string secretKey)
    {
        _publicKey = publicKey;
        _secretKey = secretKey;
        _httpClient = new HttpClient();
    }

    private string GenerateSignature(long timestamp, string body = "")
    {
        var payload = $"{timestamp}{body}";
        var keyBytes = Encoding.UTF8.GetBytes(_secretKey);
        var messageBytes = Encoding.UTF8.GetBytes(payload);

        using var hmac = new HMACSHA256(keyBytes);
        var hashBytes = hmac.ComputeHash(messageBytes);
        return Convert.ToBase64String(hashBytes);
    }

    private long GetUnixTimestamp()
    {
        return DateTimeOffset.UtcNow.ToUnixTimeSeconds();
    }

    public async Task<string> GetCountriesAsync(string language = "en")
    {
        var timestamp = GetUnixTimestamp();
        var signature = GenerateSignature(timestamp);

        var request = new HttpRequestMessage(HttpMethod.Get, 
            "https://atlasapi.solvytix.com/api/client/countries");
        
        request.Headers.Add("X-Api-PublicKey", _publicKey);
        request.Headers.Add("X-Api-Timestamp", timestamp.ToString());
        request.Headers.Add("X-Api-Signature", signature);
        request.Headers.Add("Accept-Language", language);

        var response = await _httpClient.SendAsync(request);
        response.EnsureSuccessStatusCode();
        
        return await response.Content.ReadAsStringAsync();
    }
}

// Example usage
var client = new AtlasApiClient(
    "pk_aB3xYz9mN7qWe8rT5yU2iO4pL6kJ1hG0",
    "sk_dE6fG8hJ2kL4mN9oP1qR3sT5uV7wX0yZ"
);
var countries = await client.GetCountriesAsync("en");

import hmac
import hashlib
import base64
import time
import requests

class AtlasApiClient:
    def __init__(self, public_key, secret_key):
        self.public_key = public_key
        self.secret_key = secret_key
        self.base_url = "https://atlasapi.solvytix.com/api/client"
    
    def _generate_signature(self, timestamp, body=''):
        """Generate HMAC-SHA256 signature"""
        payload = f"{timestamp}{body}"
        signature = hmac.new(
            self.secret_key.encode('utf-8'),
            payload.encode('utf-8'),
            hashlib.sha256
        ).digest()
        return base64.b64encode(signature).decode('utf-8')
    
    def _get_timestamp(self):
        """Get current Unix timestamp in seconds"""
        return int(time.time())
    
    def get_countries(self, language='en'):
        """
        Get countries list
        language: 'en' for English, 'ar' for Arabic
        """
        timestamp = self._get_timestamp()
        signature = self._generate_signature(timestamp)
        
        headers = {
            'X-Api-PublicKey': self.public_key,
            'X-Api-Timestamp': str(timestamp),
            'X-Api-Signature': signature,
            'Accept-Language': language
        }
        
        response = requests.get(
            f'{self.base_url}/countries',
            headers=headers
        )
        response.raise_for_status()
        return response.json()

# Example usage
client = AtlasApiClient(
    'pk_aB3xYz9mN7qWe8rT5yU2iO4pL6kJ1hG0',
    'sk_dE6fG8hJ2kL4mN9oP1qR3sT5uV7wX0yZ'
)

countries = client.get_countries('en')

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Instant;
import java.util.Base64;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class AtlasApiClient {
    private final HttpClient httpClient;
    private final String publicKey;
    private final String secretKey;
    private static final String BASE_URL = 
        "https://atlasapi.solvytix.com/api/client";

    public AtlasApiClient(String publicKey, String secretKey) {
        this.publicKey = publicKey;
        this.secretKey = secretKey;
        this.httpClient = HttpClient.newHttpClient();
    }

    private String generateSignature(long timestamp, String body) 
        throws Exception {
        String payload = timestamp + body;
        Mac hmac = Mac.getInstance("HmacSHA256");
        SecretKeySpec keySpec = new SecretKeySpec(
            secretKey.getBytes("UTF-8"), "HmacSHA256"
        );
        hmac.init(keySpec);
        byte[] hash = hmac.doFinal(payload.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(hash);
    }

    public String getCountries(String language) throws Exception {
        long timestamp = Instant.now().getEpochSecond();
        String signature = generateSignature(timestamp, "");

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/countries"))
            .header("X-Api-PublicKey", publicKey)
            .header("X-Api-Timestamp", String.valueOf(timestamp))
            .header("X-Api-Signature", signature)
            .header("Accept-Language", language)
            .GET()
            .build();

        HttpResponse<String> response = httpClient.send(
            request, HttpResponse.BodyHandlers.ofString()
        );
        return response.body();
    }

    public static void main(String[] args) throws Exception {
        AtlasApiClient client = new AtlasApiClient(
            "pk_aB3xYz9mN7qWe8rT5yU2iO4pL6kJ1hG0",
            "sk_dE6fG8hJ2kL4mN9oP1qR3sT5uV7wX0yZ"
        );
        String countries = client.getCountries("en");
        System.out.println(countries);
    }
}

const crypto = require('crypto');
const axios = require('axios');

class AtlasApiClient {
  constructor(publicKey, secretKey) {
    this.publicKey = publicKey;
    this.secretKey = secretKey;
    this.baseURL = 'https://atlasapi.solvytix.com/api/client';
  }

  generateSignature(timestamp, body = '') {
    const payload = `${timestamp}${body}`;
    const signature = crypto
      .createHmac('sha256', this.secretKey)
      .update(payload)
      .digest('base64');
    return signature;
  }

  async getCountries(language = 'en') {
    try {
      const timestamp = Math.floor(Date.now() / 1000);
      const signature = this.generateSignature(timestamp);

      const response = await axios.get(`${this.baseURL}/countries`, {
        headers: {
          'X-Api-PublicKey': this.publicKey,
          'X-Api-Timestamp': timestamp.toString(),
          'X-Api-Signature': signature,
          'Accept-Language': language
        }
      });
      return response.data;
    } catch (error) {
      console.error('Error:', error.response?.data || error.message);
      throw error;
    }
  }

  async getCitiesByGovernorate(governorateId, language = 'en') {
    try {
      const timestamp = Math.floor(Date.now() / 1000);
      const signature = this.generateSignature(timestamp);

      const response = await axios.get(
        `${this.baseURL}/cities/governorate/${governorateId}`,
        {
          headers: {
            'X-Api-PublicKey': this.publicKey,
            'X-Api-Timestamp': timestamp.toString(),
            'X-Api-Signature': signature,
            'Accept-Language': language
          }
        }
      );
      return response.data;
    } catch (error) {
      console.error('Error:', error.response?.data || error.message);
      throw error;
    }
  }
}

// Example usage
const client = new AtlasApiClient(
  'pk_aB3xYz9mN7qWe8rT5yU2iO4pL6kJ1hG0',
  'sk_dE6fG8hJ2kL4mN9oP1qR3sT5uV7wX0yZ'
);

// Get countries
client.getCountries('en')
  .then(data => console.log('Countries:', data))
  .catch(err => console.error(err));