#How to get families, family variants, and attributes

• PHP
• NodeJS

    function buildApiClient(): GuzzleHttp\Client
    {
        $pimUrl = 'https://url-of-your-pim.com';
        $appToken = 'your_app_token'; // Token provided during oAuth steps
    
        // If you haven't done it yet,
        // please follow the Guzzle official documentation to install the client 
        // https://docs.guzzlephp.org/en/stable/overview.html#installation
    
        // Set your client for querying Akeneo API as follows
        $client = new \GuzzleHttp\Client([
            'base_uri' => $pimUrl,
            'headers' => ['Authorization' => 'Bearer ' . $appToken],
        ]);
    }
    

    // Install the node-fetch library by following the official documentation:
    // https://www.npmjs.com/package/node-fetch
    import fetch from 'node-fetch';
    
    const pimUrl = 'https://url-of-your-pim.com';
    const accessToken = 'your_app_token'; // Token provided during oAuth steps
    
    // Set your client for querying Akeneo API as follows
    async function get(url, accessToken) {
        return await fetch(url, {
            headers: {
                'Authorization': `Bearer ${accessToken}`
            }
        });
    }
    

• PHP
• NodeJS

    $client = buildApiClient();
    
    const MAX_ITEMS = 100;
    
    $nextUrl = '/api/rest/v1/families?search={"has_products":[{"operator":"=","value":true}]}&limit=' . MAX_ITEMS;
    
    $families = $attributeCodes = [];
    do {
        // Collect families and list of unique attribute codes from API
        $response = $client->get($nextUrl);
        $data = json_decode($response->getBody()->getContents(), true);
        $families[] = $data['_embedded']['items'];
        $attributeCodes = array_merge(
            $attributeCodes,
            ...array_column($data['_embedded']['items'], 'attributes'));
    
        $nextUrl = $data['_links']['next']['href'] ?? null;
    } while (
        $nextUrl
    );
    
    $families = array_merge(...$families);
    
    $attributeCodes = array_unique($attributeCodes);
    
    // Save families and attribute codes into storage
    storeFamilies($families);
    storeAttributesCodes($attributeCodes);
    

    const maxItems = 100;
    let nextUrl = `${pimUrl}/api/rest/v1/families?search={"has_products":[{"operator":"=","value":true}]}&limit=${maxItems}`;
    
    const families = [];
    do {
        const response = await get(nextUrl, accessToken);
        const data = await response.json();
        const newFamilies = data['_embedded']['items']
        families.push(...newFamilies);
    
        nextUrl = data._links?.next?.href;
    } while (nextUrl)
    
    // Collect attributes from all families
    const attributeCodes = families.reduce(
        (acc, family) => [...acc, ...family.attributes],
        []
    );
    
    const uniqueAttributes = [...new Set(attributeCodes)];
    
    // Save families and attribute codes into storage
    storeFamilies(families);
    storeAttributeCodes(uniqueAttributes);
    

• PHP
• NodeJS

    $client = buildApiClient();
    
    $maxProductsPerPage = 100;
    $apiUrl = '/api/rest/v1/families/%s/variants?limit=%s';
    
    // Get family codes from storage
    $codes = getFamilyCodes();
    
    // Collect family variants from API
    $familyVariants = [];
    foreach ($codes as $code) {
        $nextUrl = sprintf($apiUrl, $code, $maxProductsPerPage);
        do {
            // Collect family variants from API
            $response = $client->get($nextUrl);
            $data = json_decode($response->getBody()->getContents(), true);
            $familyVariants[] = $data['_embedded']['items'];
    
            $nextUrl = $data['_links']['next']['href'] ?? null;
        } while (
            $nextUrl
        );
    }
    
    $familyVariants = array_merge(...$familyVariants);
    
    // add index to $familyVariants
    $indexedFamilyVariants = [];
    foreach ($familyVariants as $familyVariant) {
        $indexedFamilyVariants[$familyVariant['code']] = $familyVariant;
    }
    
    // Save family variants into storage
    storeFamilyVariants($indexedFamilyVariants);
    

    const maxProductsPerPage = 100;
    
    // Get family codes from storage
    const familyCodes = await getFamilyCodes();
    
    let familyVariants = [];
    for (const code of familyCodes) {
        let nextUrl = `${pimUrl}/api/rest/v1/families/${code}/variants?limit=${maxProductsPerPage}`;
        do {
            // Collect family variants from API
            const response = await get(nextUrl, accessToken);
            const data = await response.json();
            const newVariants = data['_embedded']['items'];
            familyVariants.push(...newVariants);
    
            nextUrl = data._links?.next?.href;
        } while (nextUrl)
    }
    
    // add index to familyVariants
    let indexedFamilyVariants = {};
    for (const familyVariant of familyVariants) {
        indexedFamilyVariants[familyVariant['code']] = familyVariant;
    }
    
    // Save family variants into storage
    storeFamilyVariants(indexedFamilyVariants);
    

• PHP
• NodeJS

    $client = buildApiClient();
    
    const MAX_ITEMS = 100;
    const API_URL = '/api/rest/v1/attributes?search={"code":[{"operator":"IN","value":%s}]}&limit=%s';
    
    // Get attributes codes from storage
    $attributeCodes = getAttributesCodes();
    
    // Collect attributes from API
    $rawAttributes = [];
    foreach (array_chunk($attributeCodes, MAX_ITEMS) as $chunk) {
        $response = $client->get(sprintf(API_URL, json_encode($chunk), MAX_ITEMS));
        $data = json_decode($response->getBody()->getContents(), true);
        $rawAttributes[] = $data['_embedded']['items'];
    }
    
    $rawAttributes = array_merge(...$rawAttributes);
    
    // Only keep fields needed
    $attributes = [];
    foreach ($rawAttributes as $rawAttribute) {
        $attributes[$rawAttribute['code']] = [
            'code' => $rawAttribute['code'],
            'type' => $rawAttribute['type'],
            // Add additional fields if needed
        ];
    }
    
    // save attributes into storage
    storeAttributes($attributes);
    

    const maxItems = 100;
    
    // Get attributes codes from storage
    const attributeCodes = await getAttributeCodes();
    const maxAttributesPerQuery = 10;
    
    // split attributeCodes in chucks of $maxAttributesPerQuery elements
    let chunks = [];
    while (attributeCodes.length > 0) {
        chunks.push(attributeCodes.splice(0, maxAttributesPerQuery));
    }
    
    let rawAttributes = [];
    for (const item of chunks) {
        let nextUrl = `${pimUrl}/api/rest/v1/attributes?search={"code":[{"operator":"IN","value":${JSON.stringify(item)}}]}&limit=` + maxItems;
        do {
            const response = await get(nextUrl, accessToken);
            let data = await response.json();
            let newRawAttributes = data['_embedded']['items']
            rawAttributes.push(...newRawAttributes);
            nextUrl = data._links?.next?.href;
        } while (nextUrl);
    }
    
    // Only keep fields needed
    let attributes = {};
    for (const rawAttribute of rawAttributes) {
        attributes[rawAttribute['code']] = {
            'code': rawAttribute['code'],
            'type': rawAttribute['type'],
            // Add additional fields if needed
        };
    }
    
    //save attributes into storage
    storeAttributes(attributes);
    

• PHP
• NodeJS

    // Output
    [
        'attribute_code' => [
                'code' => 'attribute_code',
                'type' => 'pim_catalog_text',
        ],
    ]
    

    // Output
    {
    	"attribute_code":
    	{
    		"code": "attribute_code",
    		"type": "pim_catalog_text"
    	}
    }