🔗 Nielsen Chase CRM API

<?php
// Nielsen Chase CRM API - PHP Client
class NielsenChaseAPI {
    private $baseUrl;
    private $apiKey;
    private $timeout;

    public function __construct($baseUrl, $apiKey) {
        $this->baseUrl = rtrim($baseUrl, '/');
        $this->apiKey = $apiKey;
        $this->timeout = 30;
    }

    private function makeRequest($method, $endpoint, $data = null) {
        $url = $this->baseUrl . '/' . ltrim($endpoint, '/');

        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_TIMEOUT => $this->timeout,
            CURLOPT_HTTPHEADER => [
                'X-API-Key: ' . $this->apiKey,
                'Content-Type: application/json',
                'Accept: application/json'
            ]
        ]);

        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);
        $error = curl_error($ch);
        curl_close($ch);

        if ($error) {
            throw new Exception('CURL Error: ' . $error);
        }

        $decodedResponse = json_decode($response, true);

        if ($httpCode >= 400) {
            $message = $decodedResponse['message'] ?? 'Unknown error';
            throw new Exception("API Error (HTTP $httpCode): $message");
        }

        return $decodedResponse;
    }

    public function healthCheck() {
        return $this->makeRequest('GET', 'health');
    }

    public function getCompanies($params = []) {
        $query = http_build_query($params);
        $endpoint = 'companies' . ($query ? '?' . $query : '');
        return $this->makeRequest('GET', $endpoint);
    }

    public function createProject($projectData) {
        return $this->makeRequest('POST', 'projects', $projectData);
    }

    public function getProjects($params = []) {
        $query = http_build_query($params);
        $endpoint = 'projects' . ($query ? '?' . $query : '');
        return $this->makeRequest('GET', $endpoint);
    }
}

// Kullanım örneği
try {
    $api = new NielsenChaseAPI(
        'https://ncportal.tech/api/external',
        'nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G'
    );

    // Health check
    $health = $api->healthCheck();
    echo "API Status: " . $health['message'] . "\n";

    // Companies listele
    $companies = $api->getCompanies(['limit' => 5]);
    echo "Found " . count($companies['data']) . " companies\n";

    // Yeni proje oluştur
    $newProject = [
        'name' => 'PHP API Test Project',
        'description' => 'Test project via PHP',
        'company_id' => '31d26468-b80d-49a9-b241-b954a4e451f9',
        'product_name' => 'PHP Test Product',
        'currency' => 'EUR',
        'priority' => 'high'
    ];

    $project = $api->createProject($newProject);
    echo "Project created: " . $project['data']['project_number'] . "\n";

} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}
?>

# Nielsen Chase CRM API - Python Client
import requests
import json
from typing import Dict, Optional, List

class NielsenChaseAPI:
    def __init__(self, base_url: str, api_key: str):
        self.base_url = base_url.rstrip('/')
        self.api_key = api_key
        self.session = requests.Session()
        self.session.headers.update({
            'X-API-Key': api_key,
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        })
        self.session.timeout = 30

    def _make_request(self, method: str, endpoint: str, data: Optional[Dict] = None,
                      params: Optional[Dict] = None) -> Dict:
        url = f"{self.base_url}/{endpoint.lstrip('/')}"

        try:
            if method.upper() == 'GET':
                response = self.session.get(url, params=params)
            elif method.upper() == 'POST':
                response = self.session.post(url, json=data, params=params)
            elif method.upper() == 'PUT':
                response = self.session.put(url, json=data, params=params)
            elif method.upper() == 'DELETE':
                response = self.session.delete(url, params=params)
            else:
                raise ValueError(f"Unsupported HTTP method: {method}")

            response.raise_for_status()
            return response.json()

        except requests.exceptions.HTTPError as e:
            try:
                error_data = response.json();
                raise Exception(f"API Error (HTTP {response.status_code}): {error_data.get('message', 'Unknown error')}");
            except json.JSONDecodeError:
                raise Exception(f"API Error (HTTP {response.status_code}): {response.text}");
        except requests.exceptions.RequestException as e:
            raise Exception(f"Request failed: {str(e)}");

    def health_check(self) -> Dict:
        return self._make_request('GET', '/health');

    def get_companies(self, limit: int = 50, offset: int = 0,
                      search: Optional[str] = None) -> Dict:
        params = {'limit': limit, 'offset': offset};
        if search:
            params['search'] = search;
        return self._make_request('GET', '/companies', params=params);

    def create_company(self, company_data: Dict) -> Dict:
        return self._make_request('POST', '/companies', data=company_data);

    def create_project(self, project_data: Dict) -> Dict:
        return self._make_request('POST', '/projects', data=project_data);

    def get_projects(self, status: Optional[str] = None,
                     company_id: Optional[str] = None, limit: int = 50) -> Dict:
        params = {'limit': limit};
        if status:
            params['status'] = status;
        if company_id:
            params['company_id'] = company_id;
        return self._make_request('GET', '/projects', params=params);

# Kullanım örneği
if __name__ == "__main__":
    # API client oluştur
    api = NielsenChaseAPI(
        base_url='https://ncportal.tech/api/external',
        api_key='nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G'
    );

    try:
        # Health check
        health = api.health_check();
        print(f"API Status: {health['message']}");

        # Companies listele
        companies = api.get_companies(limit=5);
        print(f"Found {len(companies['data'])} companies");

        # Yeni proje oluştur
        new_project = {
            'name': 'Python API Test Project',
            'description': 'Test project via Python',
            'company_id': '31d26468-b80d-49a9-b241-b954a4e451f9',
            'product_name': 'Python Test Product',
            'currency': 'USD',
            'priority': 'medium'
        };

        project = api.create_project(new_project);
        print(f"Project created: {project['data']['project_number']}");

    except Exception as e:
        print(f"Error: {e}");

// Nielsen Chase CRM API - C# Client
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class NielsenChaseAPIClient : IDisposable
{
    private readonly HttpClient _httpClient;
    private readonly string _baseUrl;

    public NielsenChaseAPIClient(string baseUrl, string apiKey)
    {
        _baseUrl = baseUrl.TrimEnd('/');
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("X-API-Key", apiKey);
        _httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
        _httpClient.Timeout = TimeSpan.FromSeconds(30);
    }

    private async Task MakeRequestAsync(HttpMethod method, string endpoint,
                                              object data = null, string queryString = "")
    {
        var url = $"{_baseUrl}/{endpoint.TrimStart('/')}{queryString}";
        var request = new HttpRequestMessage(method, url);

        if (data != null && (method == HttpMethod.Post || method == HttpMethod.Put))
        {
            var json = JsonSerializer.Serialize(data, new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
            });
            request.Content = new StringContent(json, Encoding.UTF8, "application/json");
        }

        var response = await _httpClient.SendAsync(request);
        var responseContent = await response.Content.ReadAsStringAsync();

        if (!response.IsSuccessStatusCode)
        {
            throw new HttpRequestException($"API Error (HTTP {(int)response.StatusCode}): {responseContent}");
        }

        return JsonSerializer.Deserialize(responseContent, new JsonSerializerOptions
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
        });
    }

    public async Task> HealthCheckAsync()
    {
        return await MakeRequestAsync>(HttpMethod.Get, "health");
    }

    public async Task>> GetCompaniesAsync(int limit = 50, int offset = 0, string search = null)
    {
        var queryParams = new List { $"limit={limit}", $"offset={offset}" };
        if (!string.IsNullOrEmpty(search))
            queryParams.Add($"search={search}");

        var queryString = $"?{string.Join("&", queryParams)}";
        return await MakeRequestAsync>>(HttpMethod.Get, "companies", null, queryString);
    }

    public async Task> CreateProjectAsync(CreateProjectRequest projectData)
    {
        return await MakeRequestAsync>(HttpMethod.Post, "projects", projectData);
    }

    public void Dispose()
    {
        _httpClient?.Dispose();
    }
}

// Data Models
public class ApiResponse
{
    public bool Success { get; set; }
    public T Data { get; set; }
    public string Message { get; set; }
}

public class Company
{
    public string Id { get; set; }
    public string CompanyName { get; set; }
    public string ContactPersonName { get; set; }
    public string ContactPersonEmail { get; set; }
    public bool IsActive { get; set; }
    public DateTime CreatedAt { get; set; }
}

public class Project
{
    public string Id { get; set; }
    public string ProjectNumber { get; set; }
    public string Name { get; set; }
    public string Status { get; set; }
    public string CompanyId { get; set; }
    public DateTime CreatedAt { get; set; }
}

public class CreateProjectRequest
{
    public string Name { get; set; }
    public string Description { get; set; }
    public string CompanyId { get; set; }
    public string ProductName { get; set; }
    public string Currency { get; set; }
    public string Priority { get; set; }
}

// Kullanım örneği
class Program
{
    static async Task Main(string[] args)
    {
        using var apiClient = new NielsenChaseAPIClient(
            "https://ncportal.tech/api/external",
            "nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G"
        );

        try
        {
            // Health check
            var health = await apiClient.HealthCheckAsync();
            Console.WriteLine($"API Status: {health.Message}");

            // Companies listele
            var companies = await apiClient.GetCompaniesAsync(limit: 5);
            Console.WriteLine($"Found {companies.Data.Count} companies");

            // Yeni proje oluştur
            var newProject = new CreateProjectRequest
            {
                Name = "C# API Test Project",
                Description = "Test project via C#",
                CompanyId = "31d26468-b80d-49a9-b241-b954a4e451f9",
                ProductName = "C# Test Product",
                Currency = "USD",
                Priority = "medium"
            };

            var project = await apiClient.CreateProjectAsync(newProject);
            Console.WriteLine($"Project created: {project.Data.ProjectNumber}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

// Nielsen Chase CRM API - Java Client
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.List;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategies;

public class NielsenChaseAPIClient {
    private final HttpClient httpClient;
    private final String baseUrl;
    private final String apiKey;
    private final ObjectMapper objectMapper;

    public NielsenChaseAPIClient(String baseUrl, String apiKey) {
        this.baseUrl = baseUrl.replaceAll("/$", "");
        this.apiKey = apiKey;
        this.httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        this.objectMapper = new ObjectMapper();
        this.objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
    }

    private  T makeRequest(String method, String endpoint, Object data, Class responseClass)
            throws IOException, InterruptedException {
        String url = baseUrl + "/" + endpoint.replaceAll("^/", "");

        HttpRequest.Builder requestBuilder = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("X-API-Key", apiKey)
            .header("Content-Type", "application/json")
            .header("Accept", "application/json")
            .timeout(Duration.ofSeconds(60));

        if ("GET".equals(method)) {
            requestBuilder.GET();
        } else if ("POST".equals(method)) {
            String json = objectMapper.writeValueAsString(data);
            requestBuilder.POST(HttpRequest.BodyPublishers.ofString(json));
        }

        HttpRequest request = requestBuilder.build();
        HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() >= 400) {
            throw new RuntimeException("API Error (HTTP " + response.statusCode() + "): " + response.body());
        }

        return objectMapper.readValue(response.body(), responseClass);
    }

    public ApiResponse healthCheck() throws IOException, InterruptedException {
        return makeRequest("GET", "/health", null, ApiResponse.class);
    }

    public ApiResponse> getCompanies(int limit, int offset, String search)
            throws IOException, InterruptedException {
        StringBuilder endpoint = new StringBuilder("/companies?limit=" + limit + "&offset=" + offset);
        if (search != null && !search.isEmpty()) {
            endpoint.append("&search=").append(search);
        }
        return makeRequest("GET", endpoint.toString(), null, ApiResponse.class);
    }

    public ApiResponse createProject(CreateProjectRequest projectData)
            throws IOException, InterruptedException {
        return makeRequest("POST", "/projects", projectData, ApiResponse.class);
    }

    // Data classes
    public static class ApiResponse {
        public boolean success;
        public T data;
        public String message;
    }

    public static class Company {
        public String id;
        public String companyName;
        public String contactPersonName;
        public String contactPersonEmail;
        public boolean isActive;
        public String createdAt;
    }

    public static class Project {
        public String id;
        public String projectNumber;
        public String name;
        public String status;
        public String companyId;
        public String createdAt;
    }

    public static class CreateProjectRequest {
        public String name;
        public String description;
        public String companyId;
        public String productName;
        public String currency;
        public String priority;
    }

    // Kullanım örneği
    public static void main(String[] args) {
        NielsenChaseAPIClient apiClient = new NielsenChaseAPIClient(
            "https://ncportal.tech/api/external",
            "nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G"
        );

        try {
            // Health check
            ApiResponse health = apiClient.healthCheck();
            System.out.println("API Status: " + health.message);

            // Companies listele
            ApiResponse> companies = apiClient.getCompanies(5, 0, null);
            System.out.println("Found companies");

            // Yeni proje oluştur
            CreateProjectRequest newProject = new CreateProjectRequest();
            newProject.name = "Java API Test Project";
            newProject.description = "Test project via Java";
            newProject.companyId = "31d26468-b80d-49a9-b241-b954a4e451f9";
            newProject.productName = "Java Test Product";
            newProject.currency = "USD";
            newProject.priority = "medium";

            ApiResponse project = apiClient.createProject(newProject);
            System.out.println("Project created successfully");

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

# Nielsen Chase CRM API - cURL Örnekleri

# Health Check
curl -X GET "https://ncportal.tech/api/external/health" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G" \
  -H "Accept: application/json"

# Company Listesi
curl -X GET "https://ncportal.tech/api/external/companies?limit=5&offset=0" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G" \
  -H "Accept: application/json"

# Company Arama
curl -X GET "https://ncportal.tech/api/external/companies?search=Test&limit=10" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G" \
  -H "Accept: application/json"

# Yeni Şirket Oluştur
curl -X POST "https://ncportal.tech/api/external/companies" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "company_name": "cURL Test Company",
    "contact_person_name": "Test User",
    "contact_person_email": "[email protected]",
    "contact_person_phone": "+1 555 000 0000",
    "contact_person_title": "Manager",
    "company_address": "123 Test Street",
    "company_city": "Test City"
  }'

# Yeni Proje Oluştur
curl -X POST "https://ncportal.tech/api/external/projects" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "name": "cURL Test Project",
    "description": "Test project created via cURL",
    "company_id": "31d26468-b80d-49a9-b241-b954a4e451f9",
    "product_name": "cURL Test Product",
    "currency": "USD",
    "priority": "medium"
  }'

# Proje Listesi
curl -X GET "https://ncportal.tech/api/external/projects?status=active&limit=10" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G" \
  -H "Accept: application/json"

# Proje Durumu Güncelle
curl -X PUT "https://ncportal.tech/api/external/projects/PROJECT_ID/status" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "status": "in_production",
    "notes": "Project moved to production phase"
  }'

# Abonelik Detayları
curl -X GET "https://ncportal.tech/api/external/[email protected]" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G" \
  -H "Accept: application/json"

# Destek Talebi Oluştur
curl -X POST "https://ncportal.tech/api/external/support/tickets" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "user_id": "user-uuid",
    "title": "cURL Integration Issue",
    "description": "Having trouble with API integration using cURL",
    "priority": "medium",
    "category": "technical"
  }'

# Hata Yönetimi - Response Headers
curl -i -X GET "https://ncportal.tech/api/external/health" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G"

# Verbose Output (Debugging)
curl -v -X GET "https://ncportal.tech/api/external/health" \
  -H "X-API-Key: nc_sQEywqJh4TDHHJeopcJcGXQYM1HT423G"