Query ad altri scraper

await this.parser.request(parser, preset, overrideParams, query)

await this.parser.request(parser, preset, overrideParams, query)

Ottenere risultati da un altro scraper (integrato o un altro scraper JS), gli argomenti specificati sono:

• parser - nome dello scraper (SE::Google, JS::Custom::Example)
• preset - preset delle impostazioni dello scraper chiamato
• overrideParams - hash con le sovrascritture delle impostazioni dello scraper chiamato
• query - query

Ignora parzialmente il preset dello scraper chiamato, specificato dal parametro preset. Nello specifico, le impostazioni useproxy, proxyChecker, proxybannedcleanup vengono ereditate dallo scraper che esegue la chiamata await this.parser.request.

In overrideParams è possibile sovrascrivere i parametri dello scraper chiamato; sono inoltre disponibili i seguenti flag:

overrideParams.resultArraysWithObjects

resultArraysWithObjects: 0 - determina il formato in cui restituire gli array di risultati dello scraper chiamato:

• se abilitato (1) - verranno restituiti array di oggetti

  [{link: 'link1', anchor: 'anchor1'}, {link: 'link2', anchor: 'anchor2'}, ...]
• se disabilitato (0) - verranno restituiti array standard di valori

  ['link1', 'anchor1', 'link2', 'anchor2', ...]

Esempio:

import { BaseParser } from 'a-parser-types';

class JS_DocExample extends BaseParser {
    static defaultConf: typeof BaseParser.defaultConf = {
        results_format: "$links.format('$link\n')",
        results: {
            arrays: {
                links: ['Links', [
                    ['link', 'link']
                ]]
            }
        }
    }

    async parse(set, results) {
        let response = await this.parser.request('SE::Google', 'default', {
            resultArraysWithObjects: 1,
            pagecount: 1
        }, set.query)
        results.success = response.success;
        
        if(response.success) {
            response.serp.forEach(element => {
                results.links.push(element.link);
            });
        }

        return results;
    }
}

Esempio di risultato:

https://www.speedtest.net/
https://www.investopedia.com/terms/t/t-test.asp
https://www.cdc.gov/coronavirus/2019-ncov/testing/diagnostic-testing.html
https://fast.com/
https://www.thinkwithgoogle.com/feature/testmysite/
https://projectstream.google.com/speedtest
https://www.nhs.uk/conditions/coronavirus-covid-19/testing/
https://www.fda.gov/consumers/consumer-updates/coronavirus-disease-2019-testing-basics
https://zoom.us/test
https://www.gov.uk/get-coronavirus-test
https://en.wikipedia.org/wiki/Test_(assessment)
...

overrideParams.needData

needData: 1 - determina se trasmettere (1) o meno (0) data/pages[] nella risposta, può essere utilizzato per l'ottimizzazione

overrideParams.needResults

needResults: [ ... ] - elenco dei risultati che devono essere restituiti.

Esempio:

let response = await this.parser.request('SE::Bing', 'default', {
    needResults: [
        'totalcount'
    ]
}, set.query)

Risultato:

{"success":1,"info":{"success":1,"retries":0},"totalcount":"2130000000"}

suggerimento

Funziona allo stesso modo per API::Server::Redis

overrideParams.skipProxySettingsInheritance

skipProxySettingsInheritance: 0 - questa opzione consente di disabilitare l'ereditarietà del parametro useproxy per lo scraper chiamato

Richieste a scraper che supportano la modalità batch

È supportata anche la chiamata a scraper che operano in modalità batch. Per fare ciò, in query è necessario passare un array di query nel formato ['key1', 'key2', ...].

Il risultato dell'elaborazione dello scraper chiamato sarà contenuto nell'array bulkResults, di seguito un esempio di tale array:

{
    "bulkResults": [
        {
            "success": 1,
            "someArrayResult": [...],
            "someFlatResult": '...',
            "query": "key1",
            "data": "..."
        },
        {
            "success": 1,
            "someArrayResult": [...],
            "someFlatResult": '...',
            "query": "key2",
            "data": "..."
        },
        {
            "success": 1,
            "someArrayResult": [...],
            "someFlatResult": '...',
            "query": "key3",
            "data": "..."
        }
    ],
    "success": 1,
    "info": {
        "success": 1,
        "retries": 1
    }
}

Esempio di chiamata a un altro scraper in modalità batch

import { BaseParser } from 'a-parser-types';

export class JS_Example_BulkQueries extends BaseParser {
    static defaultConf: typeof BaseParser.defaultConf = {
        version: '1.0.0',
        results: {
            flat: [
                ['views', 'Views count per month']
            ]
        },
        results_format: "$query: $views\\n",
        SE_Yandex_Direct_Frequency_preset: 'default',
        bulkQueries: 10 // impostiamo il numero di query nel "pacchetto"
    };

    static editableConf: typeof BaseParser.editableConf = [
        ['SE_Yandex_Direct_Frequency_preset', ['combobox', 'SE::Yandex::Direct::Frequency preset']]
    ];

    async parse(set, results) {
        const { success, bulkResults } = await this.parser.request(
            'SE::Yandex::Direct::Frequency',
            this.conf.SE_Yandex_Direct_Frequency_preset,
            { useAccounts: 1 },
            set.bulkQueries.map((el) => el.query) // convertiamo l'array di oggetti set.bulkQueries in un array del tipo [query1, query2, ... query10]
        );
        if(success) {
            // compiliamo i risultati in results.bulkResults
            for(let query_number = 0; query_number < set.bulkQueries.length; query_number++) {
                results.bulkResults[query_number].views = bulkResults[query_number].views;
                results.bulkResults[query_number].success = bulkResults[query_number].success;
            }
        }

        return results;
    }
}