711014209

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/ufersa/plataforma-sabia/commit/<a class=hub.com/ufersa/plataforma-sabia/commit/<a class="double-link" href="https://git"><a class=hub.com/ufersa/plataforma-sabia/commit/<a class="double-link" href="https://git"><a class=hub.com/ufersa/plataforma-sabia/commit/3178dbcc747ec115669cf61be161e4208244862a">3178dbcc7<a href="https://github.com/ufersa/plataforma-sabia/commit/3178dbcc747ec115669cf61be161e4208244862a">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/ufersa/plataforma-sabia/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ufersa/plataforma-sabia/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ufersa/plataforma-sabia/commit/3178dbcc747ec115669cf61be161e4208244862a&quot;&gt;3178dbcc7&lt;/a&gt;&lt;a href=&quot;https://github.com/ufersa/plataforma-sabia/commit/3178dbcc747ec115669cf61be161e4208244862a&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/ufersa/plataforma-sabia/commit/3178dbcc747ec115669cf61be161e420&lt;/a&gt;8244862a&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ufersa/plataforma-sabia/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ufersa/plataforma-sabia/commit/<a class="double-link" href="https://github.com/ufersa/plataforma-sabia/commit/03ab164710f65c193e431e60dada5c5c812ba65c">03ab16471</a><a href="https://github.com/ufersa/plataforma-sabia/commit/3178dbcc747ec115669cf61be161e4208244862a">&amp;quot;&amp;gt;03ab16471&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;03ab16471&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/ufersa/plataforma-sabia/commit/3178dbcc747ec115669cf61be161e42082448&lt;/a&gt;62a&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ufersa/plataforma-sabia/commit/<a class="double-link" href="https://github.com/ufersa/plataforma-sabia/commit/c3f249542">c3f249542">c3f249542</a>

Pull Request Pull Request #974: Add institutions to Algolia

Run Details

1788 of 5677 branches covered (31.5%)

Branch coverage included in aggregate %.

44 of 44 new or added lines in 4 files covered. (100.0%)

6965 of 12400 relevant lines covered (56.17%)

22.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

7.1

/packages/api/app/Commands/AlgoliaIndex.js

/* eslint-disable no-await-in-loop */
const Database = use('Database');
const Technology = use('App/Models/Technology');
const Idea = use('App/Models/Idea');
const Service = use('App/Models/Service');
const Announcement = use('App/Models/Announcement');
const Institution = use('App/Models/Institution');
const { Command } = require('@adonisjs/ace');
const ProgressBar = require('cli-progress');
const https = require('https');
const { Algolia } = require('../Utils');

class AlgoliaIndex extends Command {
        constructor() {
                super();
                this.verboseMode = false;
                this.algoliaTechnologies = Algolia.initIndex('technology.indexName');
                this.algoliaServices = Algolia.initIndex('service.indexName');
                this.algoliaIdeas = Algolia.initIndex('idea.indexName');
                this.algoliaAnnouncements = Algolia.initIndex('announcement.indexName');
                this.algoliaInstitutions = Algolia.initIndex('institution.indexName');
        }

        static get signature() {
                return `
                        algolia:index { --override?: Whether to override the index or not. }
                        { --log?: log the process. }
                        { --settings?: Override index settings. }
                `;
        }

        static get description() {
                return 'Indexes content to Algolia.';
        }

        /**
         * Logs message to the console.
         *
         * @param {string} message The message to log.
         */
        log(message) {
                if (this.verboseMode) {
                        super.info(message);
                }
        }

        /**
         * Indexes all data to algolia.
         */
        async index() {
                const progressBar = new ProgressBar.SingleBar({});
                const successfullyIntegrated = {
                        technology: 0,
                        idea: 0,
                        service: 0,
                        announcement: 0,
                        institution: 0,
                };
                let page = 0;
                let lastPage;

                // Count
                const count = (
                        await Promise.all([
                                Technology.query()
                                        .available()
                                        .getCount(),
                                Idea.getCount(),
                                Service.getCount(),
                                Announcement.query()
                                        .published()
                                        .getCount(),
                                Institution.getCount(),
                        ])
                ).reduce((acc, item) => acc + item, 0);

                progressBar.start(count, 0);

                // Index Technologies
                page = 0;
                do {
                        page += 1;
                        const technologies = await Technology.query()
                                .available()
                                .with('terms.taxonomy')
                                .with('users.role')
                                .with('users.institution')
                                .with('thumbnail')
                                .with('keywords')
                                .with('technologyCosts.costs')
                                .paginate(page);
                        const { pages } = technologies;
                        const { data } = technologies.toJSON();

                        if (data.length) {
                                await Algolia.saveIndex('technology', data, { saveMany: true });
                                successfullyIntegrated.technology += data.length;
                        }

                        progressBar.increment(data.length);
                        ({ lastPage } = pages);
                } while (page <= lastPage);

                // Index Ideas
                page = 0;
                do {
                        page += 1;
                        const ideas = await Idea.query()
                                .with('keywords')
                                .paginate(page);
                        const { pages } = ideas;
                        const { data } = ideas.toJSON();

                        if (data.length) {
                                await Algolia.saveIndex('idea', data, { saveMany: true });
                                successfullyIntegrated.idea += data.length;
                        }

                        progressBar.increment(data.length);
                        ({ lastPage } = pages);
                } while (page <= lastPage);

                // Index Services
                page = 0;
                do {
                        page += 1;
                        const services = await Service.query()
                                .with('keywords')
                                .with('user.institution')
                                .paginate(page);
                        const { pages } = services;
                        const { data } = services.toJSON();

                        if (data.length) {
                                await Algolia.saveIndex('service', data, { saveMany: true });
                                successfullyIntegrated.service += data.length;
                        }

                        progressBar.increment(data.length);
                        ({ lastPage } = pages);
                } while (page <= lastPage);

                // Index Announcement
                page = 0;
                do {
                        page += 1;
                        const announcements = await Announcement.query()
                                .published()
                                .with('keywords')
                                .with('institution')
                                .with('targetAudiences')
                                .paginate(page);
                        const { pages } = announcements;
                        const { data } = announcements.toJSON();

                        if (data.length) {
                                await Algolia.saveIndex('announcement', data, { saveMany: true });
                                successfullyIntegrated.announcement += data.length;
                        }

                        progressBar.increment(data.length);
                        ({ lastPage } = pages);
                } while (page <= lastPage);

                // Index Institution
                page = 0;
                do {
                        page += 1;
                        const institutions = await Institution.query()
                                .with('technologies', (builder) => {
                                        builder
                                                // .available()
                                                .with('thumbnail')
                                                .with('keywords')
                                                .with('technologyCosts.costs');
                                })
                                .with('services', (builder) => {
                                        builder.with('keywords').with('thumbnail');
                                })
                                .paginate(page);
                        const { pages } = institutions;
                        const { data } = institutions.toJSON();

                        if (data.length) {
                                await Algolia.saveIndex('institution', data, { saveMany: true });
                                successfullyIntegrated.institution += data.length;
                        }

                        progressBar.increment(data.length);
                        ({ lastPage } = pages);
                } while (page <= lastPage);

                progressBar.stop();

                // Report integration counter
                this.success('End of saving indexes');
                this.log('{');
                Object.entries(successfullyIntegrated).forEach(([model, quantity]) => {
                        this.log(`  "${model}": ${quantity},`);
                });
                this.log('}');
        }

        /**
         * Pushes index settings
         *
         * @see https://www.algolia.com/doc/api-reference/settings-api-parameters/
         * @param {object} algolia The algolia object
         * @param {Array} replicas The algolia index replicas.
         * @param {Array} searchableAttributes The searchable attributes
         * @param {Array} attributesForFaceting The list of attributes that will be used for faceting/filtering.
         */
        async pushSettings(algolia, replicas, searchableAttributes, attributesForFaceting) {
                algolia.setSettings({
                        searchableAttributes,
                        replicas,
                        attributesForFaceting,
                });
        }

        /**
         * Handles the command.
         *
         * @param {object} args The arguments.
         * @param {object} options Options passed.
         * @param {boolean} options.log Whether to log the indexing process.
         * @param {boolean} options.override Whether to override the exiting index or not.
         * @param {boolean} options.settings Push index settings.
         */
        async handle(args, { log, override, settings }) {
                this.verboseMode = log;
                const { indexes } = Algolia.config;
                this.log('Starting indexing process');

                const overrideIndex = override || (await this.confirm('Do you want to override indices?'));

                if (overrideIndex) {
                        this.log('Clearing all index objects\n');
                        await this.algoliaTechnologies.clearObjects();
                        await this.algoliaServices.clearObjects();
                        await this.algoliaIdeas.clearObjects();
                        await this.algoliaAnnouncements.clearObjects();
                        await this.algoliaInstitutions.clearObjects();
                }

                await this.index();

                // Change the attributes for faceting/filtering if needed
                const attributesForFaceting = {
                        technologies: [
                                'searchable(classification)',
                                'searchable(dimension)',
                                'searchable(targetAudience)',
                                'searchable(type)',
                                'searchable(forSale)',
                                'searchable(institution)',
                                'searchable(keywords)',
                        ],
                        services: ['searchable(type)', 'searchable(institution)', 'searchable(keywords)'],
                        ideas: ['searchable(keywords)'],
                        announcements: ['searchable(keywords)'],
                        institutions: [
                                'searchable(category)',
                                'searchable(types)',
                                'searchable(city)',
                                'searchable(state)',
                                'searchable(technologies.keywords)',
                                'searchable(services.keywords)',
                        ],
                };

                // Change the replicas if needed
                const replicas = {
                        technologies: [
                                {
                                        name: `${indexes.technology.indexName}_installation_time_asc`,
                                        column: 'installation_time',
                                        strategy: 'asc',
                                        attributesForFaceting: attributesForFaceting.technologies,
                                },
                                {
                                        name: `${indexes.technology.indexName}_installation_time_desc`,
                                        column: 'installation_time',
                                        strategy: 'desc',
                                        attributesForFaceting: attributesForFaceting.technologies,
                                },
                        ],
                        ideas: [
                                {
                                        name: `${indexes.idea.indexName}_created_at_asc`,
                                        column: 'created_at',
                                        strategy: 'asc',
                                        attributesForFaceting: [],
                                },
                                {
                                        name: `${indexes.idea.indexName}_created_at_desc`,
                                        column: 'created_at',
                                        strategy: 'desc',
                                        attributesForFaceting: [],
                                },
                        ],
                        announcements: [
                                {
                                        name: `${indexes.announcement.indexName}_created_at_asc`,
                                        column: 'created_at',
                                        strategy: 'asc',
                                        attributesForFaceting: [],
                                },
                                {
                                        name: `${indexes.announcement.indexName}_created_at_desc`,
                                        column: 'created_at',
                                        strategy: 'desc',
                                        attributesForFaceting: [],
                                },
                        ],
                        institutions: [
                                {
                                        name: `${indexes.institution.indexName}_created_at_asc`,
                                        column: 'created_at',
                                        strategy: 'asc',
                                        attributesForFaceting: [],
                                },
                                {
                                        name: `${indexes.institution.indexName}_created_at_desc`,
                                        column: 'created_at',
                                        strategy: 'desc',
                                        attributesForFaceting: [],
                                },
                        ],
                };

                // Report integration counter
                this.success('\nSaving replica indexes');
                this.log('[');
                for (const indexReplicas of Object.values(replicas)) {
                        for (const replica of indexReplicas) {
                                await this.createReplica(replica);
                                this.log(`  "${replica.name}",`);
                        }
                }
                this.log(']');

                const pushSettings =
                        settings || (await this.confirm('Do you want to push index settings?'));
                if (pushSettings) {
                        this.log('\nPushing index settings');

                        const settingsToPush = {
                                technology: {
                                        algolia: this.algoliaTechnologies,
                                        replicas: replicas.technologies.map((replica) => replica.name),
                                        searchableAttributes: [
                                                'title',
                                                'description',
                                                'classification',
                                                'dimension',
                                                'targetAudience',
                                                'type',
                                                'forSale',
                                                'institution',
                                                'keywords',
                                        ],
                                        attributesForFaceting: attributesForFaceting.technologies,
                                },
                                services: {
                                        algolia: this.algoliaServices,
                                        replicas: null,
                                        searchableAttributes: ['name', 'type', 'institution', 'keywords'],
                                        attributesForFaceting: attributesForFaceting.services,
                                },
                                ideas: {
                                        algolia: this.algoliaIdeas,
                                        replicas: replicas.ideas.map((replica) => replica.name),
                                        searchableAttributes: ['title', 'description', 'keywords'],
                                        attributesForFaceting: attributesForFaceting.ideas,
                                },
                                announcements: {
                                        algolia: this.algoliaAnnouncements,
                                        replicas: replicas.announcements.map((replica) => replica.name),
                                        searchableAttributes: ['title', 'description', 'keywords'],
                                        attributesForFaceting: attributesForFaceting.announcements,
                                },
                                institutions: {
                                        algolia: this.algoliaInstitutions,
                                        replicas: replicas.institutions.map((replica) => replica.name),
                                        searchableAttributes: [
                                                'name',
                                                'initials',
                                                'category',
                                                'technologies.keywords',
                                                'services.keywords',
                                        ],
                                        attributesForFaceting: attributesForFaceting.announcements,
                                },
                        };

                        for (const setting of Object.values(settingsToPush)) {
                                await this.pushSettings(
                                        setting.algolia,
                                        setting.replicas,
                                        setting.searchableAttributes,
                                        setting.attributesForFaceting,
                                );
                        }
                }

                this.success('Indexing completed');

                await this.createQuerySuggestions();

                Database.close();
        }

        /**
         * Creates an index replica.
         *
         * @param {object} options Provided options.
         * @param {string} options.name The replica name.
         * @param {string} options.column The column to be used to create the replica index.
         * @param {string} options.strategy Whether the column should be ascendent or descendent.
         * @param {string[]} options.attributesForFaceting The list of attributes for faceting.
         */
        async createReplica({ name, column, strategy, attributesForFaceting = [] }) {
                const replicaIndex = Algolia.initIndex(name);

                await replicaIndex.setSettings({
                        ranking: [
                                `${strategy}(${column})`,
                                'typo',
                                'geo',
                                'words',
                                'filters',
                                'proximity',
                                'attribute',
                                'exact',
                                'custom',
                        ],
                        attributesForFaceting,
                });
        }

        /**
         * Creates query suggestions configuration
         *
         * @see https://www.algolia.com/doc/rest-api/query-suggestions
         * @returns {void}
         */
        async createQuerySuggestions() {
                this.log('\nCreating query suggestions');
                const { appId, apiKey, indexes } = Algolia.config;

                const algoliaQuerySuggestionIndexes = [
                        {
                                sourceIndex: indexes.technology.indexName,
                                indexName: indexes.technology.querySuggestions,
                                generate: [
                                        ['classification'],
                                        ['dimension'],
                                        ['targetAudience'],
                                        ['type'],
                                        ['keywords'],
                                ],
                        },
                        {
                                sourceIndex: indexes.service.indexName,
                                indexName: indexes.service.querySuggestions,
                                generate: [['type'], ['keywords']],
                        },
                ];

                for (const { sourceIndex, indexName, generate } of algoliaQuerySuggestionIndexes) {
                        const requestData = {
                                indexName,
                                sourceIndices: [
                                        {
                                                indexName: sourceIndex,
                                                minHits: 1,
                                                generate,
                                        },
                                ],
                        };

                        const isQuerySuggestionsCreated = await this.isQuerySuggestionsCreated(
                                requestData.indexName,
                        );

                        const request = https.request(
                                {
                                        method: isQuerySuggestionsCreated ? 'PUT' : 'POST',
                                        host: 'query-suggestions.us.algolia.com',
                                        path: `/1/configs${
                                                isQuerySuggestionsCreated ? `/${requestData.indexName}` : ''
                                        }`,
                                        headers: {
                                                'X-Algolia-Application-Id': appId,
                                                'X-Algolia-API-Key': apiKey,
                                        },
                                },
                                (res) => {
                                        res.on('data', (data) => {
                                                if (res.statusCode.toString().startsWith('2')) {
                                                        this.success(
                                                                `Query suggestions configuration for ${sourceIndex} completed`,
                                                        );
                                                } else {
                                                        this.warn(`[Algolia API Status Code]: ${res.statusCode}`);
                                                        this.error(`Something wrong occurred: ${data}`);
                                                }
                                        });

                                        res.on('error', (error) => {
                                                this.error(`An error occurred: ${error}`);
                                        });
                                },
                        );

                        request.write(JSON.stringify(requestData));
                        request.end();
                }
        }

        /**
         * Returns if a given query suggestions index exists
         *
         * @param {string} indexName The index name
         * @returns {boolean} True if query suggestions index exists, false otherwise
         */
        async isQuerySuggestionsCreated(indexName) {
                const { appId, apiKey } = Algolia.config;

                const request = new Promise((resolve, reject) => {
                        https
                                .request(
                                        {
                                                method: 'GET',
                                                host: 'query-suggestions.us.algolia.com',
                                                path: `/1/configs/${indexName}`,
                                                headers: {
                                                        'X-Algolia-Application-Id': appId,
                                                        'X-Algolia-API-Key': apiKey,
                                                },
                                        },
                                        (res) => {
                                                res.setEncoding('utf8');
                                                let dataChunk;

                                                res.on('data', (data) => {
                                                        dataChunk = data;
                                                });

                                                res.on('end', () => {
                                                        resolve(JSON.parse(dataChunk));
                                                });

                                                res.on('error', (error) => {
                                                        reject(error);
                                                });
                                        },
                                )
                                .end();
                });

                const response = await request;
                return response.status !== 404;
        }
}

module.exports = AlgoliaIndex;

1	/* eslint-disable no-await-in-loop */
2	const Database = use('Database');	1✔
3	const Technology = use('App/Models/Technology');	1✔
4	const Idea = use('App/Models/Idea');	1✔
5	const Service = use('App/Models/Service');	1✔
6	const Announcement = use('App/Models/Announcement');	1✔
7	const Institution = use('App/Models/Institution');	1✔
8	const { Command } = require('@adonisjs/ace');	1✔
9	const ProgressBar = require('cli-progress');	1✔
10	const https = require('https');	1✔
11	const { Algolia } = require('../Utils');	1✔
12
13	class AlgoliaIndex extends Command {
14	constructor() {
15	super();	×
16	this.verboseMode = false;	×
17	this.algoliaTechnologies = Algolia.initIndex('technology.indexName');	×
18	this.algoliaServices = Algolia.initIndex('service.indexName');	×
19	this.algoliaIdeas = Algolia.initIndex('idea.indexName');	×
20	this.algoliaAnnouncements = Algolia.initIndex('announcement.indexName');	×
21	this.algoliaInstitutions = Algolia.initIndex('institution.indexName');	×
22	}
23
24	static get signature() {
25	return `	2✔
26	algolia:index { --override?: Whether to override the index or not. }
27	{ --log?: log the process. }
28	{ --settings?: Override index settings. }
29	`;
30	}
31
32	static get description() {
33	return 'Indexes content to Algolia.';	1✔
34	}
35
36	/**
37	* Logs message to the console.
38	*
39	* @param {string} message The message to log.
40	*/
41	log(message) {
42	if (this.verboseMode) {	×
43	super.info(message);	×
44	}
45	}
46
47	/**
48	* Indexes all data to algolia.
49	*/
50	async index() {
51	const progressBar = new ProgressBar.SingleBar({});	×
52	const successfullyIntegrated = {	×
53	technology: 0,
54	idea: 0,
55	service: 0,
56	announcement: 0,
57	institution: 0,
58	};
59	let page = 0;	×
60	let lastPage;
61
62	// Count
63	const count = (	×
64	await Promise.all([
65	Technology.query()
66	.available()
67	.getCount(),
68	Idea.getCount(),
69	Service.getCount(),
70	Announcement.query()
71	.published()
72	.getCount(),
73	Institution.getCount(),
74	])
75	).reduce((acc, item) => acc + item, 0);	×
76
77	progressBar.start(count, 0);	×
78
79	// Index Technologies
80	page = 0;	×
81	do {	×
82	page += 1;	×
83	const technologies = await Technology.query()	×
84	.available()
85	.with('terms.taxonomy')
86	.with('users.role')
87	.with('users.institution')
88	.with('thumbnail')
89	.with('keywords')
90	.with('technologyCosts.costs')
91	.paginate(page);
92	const { pages } = technologies;	×
93	const { data } = technologies.toJSON();	×
94
95	if (data.length) {	×
96	await Algolia.saveIndex('technology', data, { saveMany: true });	×
97	successfullyIntegrated.technology += data.length;	×
98	}
99
100	progressBar.increment(data.length);	×
101	({ lastPage } = pages);	×
102	} while (page <= lastPage);
103
104	// Index Ideas
105	page = 0;	×
106	do {	×
107	page += 1;	×
108	const ideas = await Idea.query()	×
109	.with('keywords')
110	.paginate(page);
111	const { pages } = ideas;	×
112	const { data } = ideas.toJSON();	×
113
114	if (data.length) {	×
115	await Algolia.saveIndex('idea', data, { saveMany: true });	×
116	successfullyIntegrated.idea += data.length;	×
117	}
118
119	progressBar.increment(data.length);	×
120	({ lastPage } = pages);	×
121	} while (page <= lastPage);
122
123	// Index Services
124	page = 0;	×
125	do {	×
126	page += 1;	×
127	const services = await Service.query()	×
128	.with('keywords')
129	.with('user.institution')
130	.paginate(page);
131	const { pages } = services;	×
132	const { data } = services.toJSON();	×
133
134	if (data.length) {	×
135	await Algolia.saveIndex('service', data, { saveMany: true });	×
136	successfullyIntegrated.service += data.length;	×
137	}
138
139	progressBar.increment(data.length);	×
140	({ lastPage } = pages);	×
141	} while (page <= lastPage);
142
143	// Index Announcement
144	page = 0;	×
145	do {	×
146	page += 1;	×
147	const announcements = await Announcement.query()	×
148	.published()
149	.with('keywords')
150	.with('institution')
151	.with('targetAudiences')
152	.paginate(page);
153	const { pages } = announcements;	×
154	const { data } = announcements.toJSON();	×
155
156	if (data.length) {	×
157	await Algolia.saveIndex('announcement', data, { saveMany: true });	×
158	successfullyIntegrated.announcement += data.length;	×
159	}
160
161	progressBar.increment(data.length);	×
162	({ lastPage } = pages);	×
163	} while (page <= lastPage);
164
165	// Index Institution
166	page = 0;	×
167	do {	×
168	page += 1;	×
169	const institutions = await Institution.query()	×
170	.with('technologies', (builder) => {
171	builder	×
172	// .available()
173	.with('thumbnail')
174	.with('keywords')
175	.with('technologyCosts.costs');
176	})
177	.with('services', (builder) => {
178	builder.with('keywords').with('thumbnail');	×
179	})
180	.paginate(page);
181	const { pages } = institutions;	×
182	const { data } = institutions.toJSON();	×
183
184	if (data.length) {	×
185	await Algolia.saveIndex('institution', data, { saveMany: true });	×
186	successfullyIntegrated.institution += data.length;	×
187	}
188
189	progressBar.increment(data.length);	×
190	({ lastPage } = pages);	×
191	} while (page <= lastPage);
192
193	progressBar.stop();	×
194
195	// Report integration counter
196	this.success('End of saving indexes');	×
197	this.log('{');	×
198	Object.entries(successfullyIntegrated).forEach(([model, quantity]) => {	×
199	this.log(` "${model}": ${quantity},`);	×
200	});
201	this.log('}');	×
202	}
203
204	/**
205	* Pushes index settings
206	*
207	* @see https://www.algolia.com/doc/api-reference/settings-api-parameters/
208	* @param {object} algolia The algolia object
209	* @param {Array} replicas The algolia index replicas.
210	* @param {Array} searchableAttributes The searchable attributes
211	* @param {Array} attributesForFaceting The list of attributes that will be used for faceting/filtering.
212	*/
213	async pushSettings(algolia, replicas, searchableAttributes, attributesForFaceting) {
214	algolia.setSettings({	×
215	searchableAttributes,
216	replicas,
217	attributesForFaceting,
218	});
219	}
220
221	/**
222	* Handles the command.
223	*
224	* @param {object} args The arguments.
225	* @param {object} options Options passed.
226	* @param {boolean} options.log Whether to log the indexing process.
227	* @param {boolean} options.override Whether to override the exiting index or not.
228	* @param {boolean} options.settings Push index settings.
229	*/
230	async handle(args, { log, override, settings }) {
231	this.verboseMode = log;	×
232	const { indexes } = Algolia.config;	×
233	this.log('Starting indexing process');	×
234
235	const overrideIndex = override \|\| (await this.confirm('Do you want to override indices?'));	×
236
237	if (overrideIndex) {	×
238	this.log('Clearing all index objects\n');	×
239	await this.algoliaTechnologies.clearObjects();	×
240	await this.algoliaServices.clearObjects();	×
241	await this.algoliaIdeas.clearObjects();	×
242	await this.algoliaAnnouncements.clearObjects();	×
243	await this.algoliaInstitutions.clearObjects();	×
244	}
245
246	await this.index();	×
247
248	// Change the attributes for faceting/filtering if needed
249	const attributesForFaceting = {	×
250	technologies: [
251	'searchable(classification)',
252	'searchable(dimension)',
253	'searchable(targetAudience)',
254	'searchable(type)',
255	'searchable(forSale)',
256	'searchable(institution)',
257	'searchable(keywords)',
258	],
259	services: ['searchable(type)', 'searchable(institution)', 'searchable(keywords)'],
260	ideas: ['searchable(keywords)'],
261	announcements: ['searchable(keywords)'],
262	institutions: [
263	'searchable(category)',
264	'searchable(types)',
265	'searchable(city)',
266	'searchable(state)',
267	'searchable(technologies.keywords)',
268	'searchable(services.keywords)',
269	],
270	};
271
272	// Change the replicas if needed
273	const replicas = {	×
274	technologies: [
275	{
276	name: `${indexes.technology.indexName}_installation_time_asc`,
277	column: 'installation_time',
278	strategy: 'asc',
279	attributesForFaceting: attributesForFaceting.technologies,
280	},
281	{
282	name: `${indexes.technology.indexName}_installation_time_desc`,
283	column: 'installation_time',
284	strategy: 'desc',
285	attributesForFaceting: attributesForFaceting.technologies,
286	},
287	],
288	ideas: [
289	{
290	name: `${indexes.idea.indexName}_created_at_asc`,
291	column: 'created_at',
292	strategy: 'asc',
293	attributesForFaceting: [],
294	},
295	{
296	name: `${indexes.idea.indexName}_created_at_desc`,
297	column: 'created_at',
298	strategy: 'desc',
299	attributesForFaceting: [],
300	},
301	],
302	announcements: [
303	{
304	name: `${indexes.announcement.indexName}_created_at_asc`,
305	column: 'created_at',
306	strategy: 'asc',
307	attributesForFaceting: [],
308	},
309	{
310	name: `${indexes.announcement.indexName}_created_at_desc`,
311	column: 'created_at',
312	strategy: 'desc',
313	attributesForFaceting: [],
314	},
315	],
316	institutions: [
317	{
318	name: `${indexes.institution.indexName}_created_at_asc`,
319	column: 'created_at',
320	strategy: 'asc',
321	attributesForFaceting: [],
322	},
323	{
324	name: `${indexes.institution.indexName}_created_at_desc`,
325	column: 'created_at',
326	strategy: 'desc',
327	attributesForFaceting: [],
328	},
329	],
330	};
331
332	// Report integration counter
333	this.success('\nSaving replica indexes');	×
334	this.log('[');	×
335	for (const indexReplicas of Object.values(replicas)) {	×
336	for (const replica of indexReplicas) {	×
337	await this.createReplica(replica);	×
338	this.log(` "${replica.name}",`);	×
339	}
340	}
341	this.log(']');	×
342
343	const pushSettings =
344	settings \|\| (await this.confirm('Do you want to push index settings?'));	×
345	if (pushSettings) {	×
346	this.log('\nPushing index settings');	×
347
348	const settingsToPush = {	×
349	technology: {
350	algolia: this.algoliaTechnologies,
351	replicas: replicas.technologies.map((replica) => replica.name),	×
352	searchableAttributes: [
353	'title',
354	'description',
355	'classification',
356	'dimension',
357	'targetAudience',
358	'type',
359	'forSale',
360	'institution',
361	'keywords',
362	],
363	attributesForFaceting: attributesForFaceting.technologies,
364	},
365	services: {
366	algolia: this.algoliaServices,
367	replicas: null,
368	searchableAttributes: ['name', 'type', 'institution', 'keywords'],
369	attributesForFaceting: attributesForFaceting.services,
370	},
371	ideas: {
372	algolia: this.algoliaIdeas,
373	replicas: replicas.ideas.map((replica) => replica.name),	×
374	searchableAttributes: ['title', 'description', 'keywords'],
375	attributesForFaceting: attributesForFaceting.ideas,
376	},
377	announcements: {
378	algolia: this.algoliaAnnouncements,
379	replicas: replicas.announcements.map((replica) => replica.name),	×
380	searchableAttributes: ['title', 'description', 'keywords'],
381	attributesForFaceting: attributesForFaceting.announcements,
382	},
383	institutions: {
384	algolia: this.algoliaInstitutions,
385	replicas: replicas.institutions.map((replica) => replica.name),	×
386	searchableAttributes: [
387	'name',
388	'initials',
389	'category',
390	'technologies.keywords',
391	'services.keywords',
392	],
393	attributesForFaceting: attributesForFaceting.announcements,
394	},
395	};
396
397	for (const setting of Object.values(settingsToPush)) {	×
398	await this.pushSettings(	×
399	setting.algolia,
400	setting.replicas,
401	setting.searchableAttributes,
402	setting.attributesForFaceting,
403	);
404	}
405	}
406
407	this.success('Indexing completed');	×
408
409	await this.createQuerySuggestions();	×
410
411	Database.close();	×
412	}
413
414	/**
415	* Creates an index replica.
416	*
417	* @param {object} options Provided options.
418	* @param {string} options.name The replica name.
419	* @param {string} options.column The column to be used to create the replica index.
420	* @param {string} options.strategy Whether the column should be ascendent or descendent.
421	* @param {string[]} options.attributesForFaceting The list of attributes for faceting.
422	*/
423	async createReplica({ name, column, strategy, attributesForFaceting = [] }) {	×
424	const replicaIndex = Algolia.initIndex(name);	×
425
426	await replicaIndex.setSettings({	×
427	ranking: [
428	`${strategy}(${column})`,
429	'typo',
430	'geo',
431	'words',
432	'filters',
433	'proximity',
434	'attribute',
435	'exact',
436	'custom',
437	],
438	attributesForFaceting,
439	});
440	}
441
442	/**
443	* Creates query suggestions configuration
444	*
445	* @see https://www.algolia.com/doc/rest-api/query-suggestions
446	* @returns {void}
447	*/
448	async createQuerySuggestions() {
449	this.log('\nCreating query suggestions');	×
450	const { appId, apiKey, indexes } = Algolia.config;	×
451
452	const algoliaQuerySuggestionIndexes = [	×
453	{
454	sourceIndex: indexes.technology.indexName,
455	indexName: indexes.technology.querySuggestions,
456	generate: [
457	['classification'],
458	['dimension'],
459	['targetAudience'],
460	['type'],
461	['keywords'],
462	],
463	},
464	{
465	sourceIndex: indexes.service.indexName,
466	indexName: indexes.service.querySuggestions,
467	generate: [['type'], ['keywords']],
468	},
469	];
470
471	for (const { sourceIndex, indexName, generate } of algoliaQuerySuggestionIndexes) {	×
472	const requestData = {	×
473	indexName,
474	sourceIndices: [
475	{
476	indexName: sourceIndex,
477	minHits: 1,
478	generate,
479	},
480	],
481	};
482
483	const isQuerySuggestionsCreated = await this.isQuerySuggestionsCreated(	×
484	requestData.indexName,
485	);
486
487	const request = https.request(	×
488	{
489	method: isQuerySuggestionsCreated ? 'PUT' : 'POST',	×
490	host: 'query-suggestions.us.algolia.com',
491	path: `/1/configs${
492	isQuerySuggestionsCreated ? `/${requestData.indexName}` : ''	×
493	}`,
494	headers: {
495	'X-Algolia-Application-Id': appId,
496	'X-Algolia-API-Key': apiKey,
497	},
498	},
499	(res) => {
500	res.on('data', (data) => {	×
501	if (res.statusCode.toString().startsWith('2')) {	×
502	this.success(	×
503	`Query suggestions configuration for ${sourceIndex} completed`,
504	);
505	} else {
506	this.warn(`[Algolia API Status Code]: ${res.statusCode}`);	×
507	this.error(`Something wrong occurred: ${data}`);	×
508	}
509	});
510
511	res.on('error', (error) => {	×
512	this.error(`An error occurred: ${error}`);	×
513	});
514	},
515	);
516
517	request.write(JSON.stringify(requestData));	×
518	request.end();	×
519	}
520	}
521
522	/**
523	* Returns if a given query suggestions index exists
524	*
525	* @param {string} indexName The index name
526	* @returns {boolean} True if query suggestions index exists, false otherwise
527	*/
528	async isQuerySuggestionsCreated(indexName) {
529	const { appId, apiKey } = Algolia.config;	×
530
531	const request = new Promise((resolve, reject) => {	×
532	https	×
533	.request(
534	{
535	method: 'GET',
536	host: 'query-suggestions.us.algolia.com',
537	path: `/1/configs/${indexName}`,
538	headers: {
539	'X-Algolia-Application-Id': appId,
540	'X-Algolia-API-Key': apiKey,
541	},
542	},
543	(res) => {
544	res.setEncoding('utf8');	×
545	let dataChunk;
546
547	res.on('data', (data) => {	×
548	dataChunk = data;	×
549	});
550
551	res.on('end', () => {	×
552	resolve(JSON.parse(dataChunk));	×
553	});
554
555	res.on('error', (error) => {	×
556	reject(error);	×
557	});
558	},
559	)
560	.end();
561	});
562
563	const response = await request;	×
564	return response.status !== 404;	×
565	}
566	}
567
568	module.exports = AlgoliaIndex;	1✔

ufersa / plataforma-sabia / 711014209

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous