Query's naar andere scrapers

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

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

Resultaten ophalen van een andere scraper (ingebouwd of een andere JS-scraper), waarbij de volgende argumenten worden opgegeven:

• parser - naam van de scraper (SE::Google, JS::Custom::Example)
• preset - instellingen-preset van de aangeroepen scraper
• overrideParams - hash met overschrijvingen van de instellingen van de aangeroepen scraper
• query - query

Negeert gedeeltelijk de preset van de aangeroepen scraper die wordt opgegeven door de parameter preset. Met name de instellingen useproxy, proxyChecker, proxybannedcleanup worden overgenomen van de scraper die await this.parser.request aanroept.

In overrideParams kunnen parameters van de aangeroepen scraper worden overschreven, ook zijn de volgende vlaggen beschikbaar:

overrideParams.resultArraysWithObjects

resultArraysWithObjects: 0 - bepaalt in welk formaat de resultaat-arrays van de aangeroepen scraper worden geretourneerd:

• indien ingeschakeld (1) - er worden arrays van objecten geretourneerd

  [{link: 'link1', anchor: 'anchor1'}, {link: 'link2', anchor: 'anchor2'}, ...]
• indien uitgeschakeld (0) - er worden standaard arrays van waarden geretourneerd

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

Voorbeeld:

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;
    }
}

Voorbeeld van resultaat:

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 - bepaalt of data/pages[] wel (1) of niet (0) in het antwoord moet worden doorgegeven, kan worden gebruikt voor optimalisatie

overrideParams.needResults

needResults: [ ... ] - lijst met resultaten die moeten worden geretourneerd.

Voorbeeld:

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

Resultaat:

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

tip

Hetzelfde geldt voor API::Server::Redis

overrideParams.skipProxySettingsInheritance

skipProxySettingsInheritance: 0 - deze optie maakt het mogelijk om de overerving van de parameter useproxy voor de aangeroepen scraper uit te schakelen

Query's naar scrapers die de batch-modus ondersteunen

Het is ook mogelijk om scrapers aan te roepen die in batch-modus werken. Hiervoor moet in query een array van query's in de vorm ['key1', 'key2', ...] worden doorgegeven.

Het resultaat van de verwerking door de aangeroepen scraper zal worden opgenomen in de array bulkResults, hieronder een voorbeeld van zo'n 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
    }
}

Voorbeeld van het aanroepen van een andere scraper in batch-modus

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 // instellen van het aantal query's in een "batch"
    };

    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) // we zetten de array van objecten set.bulkQueries om naar een array van het type [query1, query2, ... query10]
        );
        if(success) {
            // we vullen de resultaten 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;
    }
}