0978eb06-5436-4a92-9a45-60a3d52c490f

Build # 0978eb06-5436-4a92-9a45-60a3d52c490f

Build Type

push

circleci

Committed by GitHub

Commit Message

fix(localization): fallback for language codes with countries (#856)

Run Details

1099 of 1513 branches covered (72.64%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

2842 of 3166 relevant lines covered (89.77%)

6790.55 hits per line

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

86.61

/src/ContentTypeCache.ts

import axios from 'axios';
import { crc32 } from 'crc';
import * as merge from 'merge';
import * as qs from 'qs';

import H5pError from './helpers/H5pError';
import Logger from './helpers/Logger';
import {
    IH5PConfig,
    IHubContentType,
    IKeyValueStorage,
    IRegistrationData,
    IUsageStatistics
} from './types';

const log = new Logger('ContentTypeCache');

/**
 * This class caches the information about the content types on the H5P Hub.
 *
 * IT DOES NOT exactly correspond to the ContentTypeCache of the original PHP implementation,
 * as it only caches the data (and converts it to a local format). It DOES NOT add information
 * about locally installed libraries and user rights. ContentTypeInformationRepository is meant to do this.
 *
 * Usage:
 * - Get the content type information by calling get().
 * - The method updateIfNecessary() should be called regularly, e.g. through a cron-job.
 * - Use contentTypeCacheRefreshInterval in the IH5PConfig object to set how often
 *   the update should be performed. You can also use forceUpdate() if you want to bypass the
 *   interval.
 */
export default class ContentTypeCache {
    /**
     *
     * @param config The configuration to use.
     * @param storage The storage object.
     */
    constructor(config: IH5PConfig, storage: IKeyValueStorage) {
        log.info(`initialize`);
        this.config = config;
        this.storage = storage;
    }

    private config: IH5PConfig;
    private storage: IKeyValueStorage;
    /**
     * Converts an entry from the H5P Hub into a format with flattened versions and integer date values.
     * @param entry the entry as received from H5P Hub
     * @returns the local content type object
     */
    private static convertCacheEntryToLocalFormat(entry: any): IHubContentType {
        log.debug(`converting Cache Entry to local format`);
        return {
            categories: entry.categories || [],
            createdAt: Date.parse(entry.createdAt),
            description: entry.description,
            example: entry.example,
            h5pMajorVersion: entry.coreApiVersionNeeded.major,
            h5pMinorVersion: entry.coreApiVersionNeeded.minor,
            icon: entry.icon,
            isRecommended: entry.isRecommended,
            keywords: entry.keywords || [],
            license: entry.license,
            machineName: entry.id,
            majorVersion: entry.version.major,
            minorVersion: entry.version.minor,
            owner: entry.owner,
            patchVersion: entry.version.patch,
            popularity: entry.popularity,
            screenshots: entry.screenshots,
            summary: entry.summary,
            title: entry.title,
            tutorial: entry.tutorial || '',
            updatedAt: Date.parse(entry.updatedAt)
        };
    }

    /**
     * Creates an identifier for the running instance.
     * @returns id
     */
    private static generateLocalId(): string {
        log.debug(`generating local Id`);
        return crc32(__dirname);
    }

    /**
     * Downloads information about available content types from the H5P Hub. This method will
     * create a UUID to identify this site if required.
     * @returns content types
     */
    public async downloadContentTypesFromHub(): Promise<any[]> {
        log.info(
            `downloading content types from hub ${this.config.hubContentTypesEndpoint}`
        );
        await this.registerOrGetUuid();
        let formData = this.compileRegistrationData();
        if (this.config.sendUsageStatistics) {
            formData = merge.recursive(
                true,
                formData,
                this.compileUsageStatistics()
            );
        }

        const response = await axios.post(
            this.config.hubContentTypesEndpoint,
            qs.stringify(formData)
        );
        if (response.status !== 200) {
            throw new H5pError(
                'error-communicating-with-hub',
                {
                    statusCode: response.status.toString(),
                    statusText: response.statusText
                },
                504
            );
        }
        if (!response.data) {
            throw new H5pError(
                'error-communicating-with-hub-no-status',
                {},
                504
            );
        }

        return response.data.contentTypes;
    }

    /**
     * Downloads the content type information from the H5P Hub and stores it in the storage object.
     * @returns the downloaded (and saved) cache; undefined if it failed (e.g. because Hub was unreachable)
     */
    public async forceUpdate(): Promise<any> {
        log.info(`forcing update`);
        let cacheInHubFormat;
        try {
            cacheInHubFormat = await this.downloadContentTypesFromHub();
            if (!cacheInHubFormat) {
                return undefined;
            }
        } catch (error) {
            log.error(error);
            return undefined;
        }
        const cacheInInternalFormat = cacheInHubFormat.map(
            ContentTypeCache.convertCacheEntryToLocalFormat
        );
        await this.storage.save('contentTypeCache', cacheInInternalFormat);
        await this.storage.save('contentTypeCacheUpdate', Date.now());
        return cacheInInternalFormat;
    }

    /**
     * Returns the cache data.
     * @param machineNames (optional) The method only returns content type cache data for these machine names.
     * @returns Cached hub data in a format in which the version objects are flattened into the main object,
     */
    public async get(...machineNames: string[]): Promise<IHubContentType[]> {
        log.info(`getting content types`);

        let cache = await this.storage.load('contentTypeCache');
        if (!cache) {
            log.info(
                'ContentTypeCache was never updated before. Downloading it from the H5P Hub...'
            );
            // try updating cache if it is empty for some reason
            cache = await this.forceUpdate();
            // if the cache is still empty (e.g. because no connection to the H5P Hub can be established, return an empty array)
            if (!cache) {
                log.info(
                    'ContentTypeCache could not be retrieved from H5P Hub.'
                );
                return [];
            }
        }

        if (!machineNames || machineNames.length === 0) {
            return cache;
        }
        return cache.filter((contentType: IHubContentType) =>
            machineNames.some(
                (machineName) => machineName === contentType.machineName
            )
        );
    }

    /**
     * Returns the date and time of the last update of the cache.
     * @returns the date and time; undefined if the cache was never updated before.
     */
    public async getLastUpdate(): Promise<Date> {
        const lastUpdate = await this.storage.load('contentTypeCacheUpdate');
        return lastUpdate;
    }

    /**
     * Checks if the cache is not up to date anymore (update interval exceeded).
     * @returns true if cache is outdated, false if not
     */
    public async isOutdated(): Promise<boolean> {
        log.info(`checking if content type cache is up to date`);
        const lastUpdate = await this.storage.load('contentTypeCacheUpdate');
        return (
            !lastUpdate ||
            Date.now() - lastUpdate >
                this.config.contentTypeCacheRefreshInterval
        );
    }

    /**
     * If the running site has already been registered at the H5P hub, this method will
     * return the UUID of it. If it hasn't been registered yet, it will do so and store
     * the UUID in the storage object.
     * @returns uuid
     */
    public async registerOrGetUuid(): Promise<string> {
        log.info(
            `registering or getting uuid from hub ${this.config.hubRegistrationEndpoint}`
        );
        if (this.config.uuid && this.config.uuid !== '') {
            return this.config.uuid;
        }
        const response = await axios.post(
            this.config.hubRegistrationEndpoint,
            this.compileRegistrationData()
        );
        if (response.status !== 200) {
            throw new H5pError(
                'error-registering-at-hub',
                {
                    statusCode: response.status.toString(),
                    statusText: response.statusText
                },
                500
            );
        }
        if (!response.data || !response.data.uuid) {
            throw new H5pError('error-registering-at-hub-no-status', {}, 500);
        }
        log.debug(`setting uuid to ${response.data.uuid}`);
        this.config.uuid = response.data.uuid;
        await this.config.save();
        return this.config.uuid;
    }

    /**
     * Checks if the interval between updates has been exceeded and updates the cache if necessary.
     * @returns true if cache was updated, false if not
     */
    public async updateIfNecessary(): Promise<boolean> {
        log.info(`checking if update is necessary`);
        const oldCache = await this.storage.load('contentTypeCache');
        if (!oldCache || (await this.isOutdated())) {
            log.info(`update is necessary`);
            return (await this.forceUpdate()) !== undefined;
        }
        log.info(`no update necessary`);
        return false;
    }

    /**
     * @returns An object with the registration data as required by the H5P Hub
     */
    private compileRegistrationData(): IRegistrationData {
        log.debug(
            `compiling registration data for hub ${this.config.hubRegistrationEndpoint}`
        );
        return {
            core_api_version: `${this.config.coreApiVersion.major}.${this.config.coreApiVersion.minor}`,
            disabled: this.config.fetchingDisabled,
            h5p_version: this.config.h5pVersion,
            local_id: ContentTypeCache.generateLocalId(),
            platform_name: this.config.platformName,
            platform_version: this.config.platformVersion,
            type: this.config.siteType,
            uuid: this.config.uuid
        };
    }

    /**
     * @returns An object with usage statistics as required by the H5P Hub
     */
    private compileUsageStatistics(): IUsageStatistics {
        log.info(`compiling usage statistics`);
        return {
            libraries: {}, // TODO: add library information here
            num_authors: 0 // number of active authors
        };
    }
}

1	import axios from 'axios';	24✔
2	import { crc32 } from 'crc';	24✔
3	import * as merge from 'merge';	24✔
4	import * as qs from 'qs';	24✔
5
6	import H5pError from './helpers/H5pError';	24✔
7	import Logger from './helpers/Logger';	24✔
8	import {
9	IH5PConfig,
10	IHubContentType,
11	IKeyValueStorage,
12	IRegistrationData,
13	IUsageStatistics
14	} from './types';
15
16	const log = new Logger('ContentTypeCache');	24✔
17
18	/**
19	* This class caches the information about the content types on the H5P Hub.
20	*
21	* IT DOES NOT exactly correspond to the ContentTypeCache of the original PHP implementation,
22	* as it only caches the data (and converts it to a local format). It DOES NOT add information
23	* about locally installed libraries and user rights. ContentTypeInformationRepository is meant to do this.
24	*
25	* Usage:
26	* - Get the content type information by calling get().
27	* - The method updateIfNecessary() should be called regularly, e.g. through a cron-job.
28	* - Use contentTypeCacheRefreshInterval in the IH5PConfig object to set how often
29	* the update should be performed. You can also use forceUpdate() if you want to bypass the
30	* interval.
31	*/
32	export default class ContentTypeCache {	24✔
33	/**
34	*
35	* @param config The configuration to use.
36	* @param storage The storage object.
37	*/
38	constructor(config: IH5PConfig, storage: IKeyValueStorage) {
39	log.info(`initialize`);	119✔
40	this.config = config;	119✔
41	this.storage = storage;	119✔
42	}
43
44	private config: IH5PConfig;
45	private storage: IKeyValueStorage;
46	/**
47	* Converts an entry from the H5P Hub into a format with flattened versions and integer date values.
48	* @param entry the entry as received from H5P Hub
49	* @returns the local content type object
50	*/
51	private static convertCacheEntryToLocalFormat(entry: any): IHubContentType {	24✔
52	log.debug(`converting Cache Entry to local format`);	575✔
53	return {	575✔
54	categories: entry.categories \|\| [],	656✔
55	createdAt: Date.parse(entry.createdAt),
56	description: entry.description,
57	example: entry.example,
58	h5pMajorVersion: entry.coreApiVersionNeeded.major,
59	h5pMinorVersion: entry.coreApiVersionNeeded.minor,
60	icon: entry.icon,
61	isRecommended: entry.isRecommended,
62	keywords: entry.keywords \|\| [],	653✔
63	license: entry.license,
64	machineName: entry.id,
65	majorVersion: entry.version.major,
66	minorVersion: entry.version.minor,
67	owner: entry.owner,
68	patchVersion: entry.version.patch,
69	popularity: entry.popularity,
70	screenshots: entry.screenshots,
71	summary: entry.summary,
72	title: entry.title,
73	tutorial: entry.tutorial \|\| '',	851✔
74	updatedAt: Date.parse(entry.updatedAt)
75	};
76	}
77
78	/**
79	* Creates an identifier for the running instance.
80	* @returns id
81	*/
82	private static generateLocalId(): string {	24✔
83	log.debug(`generating local Id`);	41✔
84	return crc32(__dirname);	41✔
85	}
86
87	/**
88	* Downloads information about available content types from the H5P Hub. This method will
89	* create a UUID to identify this site if required.
90	* @returns content types
91	*/
92	public async downloadContentTypesFromHub(): Promise<any[]> {	24✔
93	log.info(	20✔
94	`downloading content types from hub ${this.config.hubContentTypesEndpoint}`
95	);
96	await this.registerOrGetUuid();	40✔
97	let formData = this.compileRegistrationData();	19✔
98	if (this.config.sendUsageStatistics) {	19!
99	formData = merge.recursive(	×
100	true,
101	formData,
102	this.compileUsageStatistics()
103	);
104	}
105
106	const response = await axios.post(	19✔
107	this.config.hubContentTypesEndpoint,
108	qs.stringify(formData)
109	);
110	if (response.status !== 200) {	17!
111	throw new H5pError(	×
112	'error-communicating-with-hub',
113	{
114	statusCode: response.status.toString(),
115	statusText: response.statusText
116	},
117	504
118	);
119	}
120	if (!response.data) {	17!
121	throw new H5pError(	×
122	'error-communicating-with-hub-no-status',
123	{},
124	504
125	);
126	}
127
128	return response.data.contentTypes;	17✔
129	}
130
131	/**
132	* Downloads the content type information from the H5P Hub and stores it in the storage object.
133	* @returns the downloaded (and saved) cache; undefined if it failed (e.g. because Hub was unreachable)
134	*/
135	public async forceUpdate(): Promise<any> {	24✔
136	log.info(`forcing update`);	20✔
137	let cacheInHubFormat;
138	try {
139	cacheInHubFormat = await this.downloadContentTypesFromHub();	20✔
140	if (!cacheInHubFormat) {	17!
141	return undefined;	×
142	}
143	} catch (error) {
144	log.error(error);	3✔
145	return undefined;	3✔
146	}
147	const cacheInInternalFormat = cacheInHubFormat.map(	17✔
148	ContentTypeCache.convertCacheEntryToLocalFormat
149	);
150	await this.storage.save('contentTypeCache', cacheInInternalFormat);	34✔
151	await this.storage.save('contentTypeCacheUpdate', Date.now());	34✔
152	return cacheInInternalFormat;	17✔
153	}
154
155	/**
156	* Returns the cache data.
157	* @param machineNames (optional) The method only returns content type cache data for these machine names.
158	* @returns Cached hub data in a format in which the version objects are flattened into the main object,
159	*/
160	public async get(...machineNames: string[]): Promise<IHubContentType[]> {	50✔
161	log.info(`getting content types`);	20✔
162
163	let cache = await this.storage.load('contentTypeCache');	20✔
164	if (!cache) {	28✔
165	log.info(	12✔
166	'ContentTypeCache was never updated before. Downloading it from the H5P Hub...'
167	);
168	// try updating cache if it is empty for some reason
169	cache = await this.forceUpdate();	12✔
170	// if the cache is still empty (e.g. because no connection to the H5P Hub can be established, return an empty array)
171	if (!cache) {	12✔
172	log.info(	3✔
173	'ContentTypeCache could not be retrieved from H5P Hub.'
174	);
175	return [];	3✔
176	}
177	}
178
179	if (!machineNames \|\| machineNames.length === 0) {	17✔
180	return cache;	11✔
181	}
182	return cache.filter((contentType: IHubContentType) =>	6✔
183	machineNames.some(	178✔
184	(machineName) => machineName === contentType.machineName	178✔
185	)
186	);
187	}
188
189	/**
190	* Returns the date and time of the last update of the cache.
191	* @returns the date and time; undefined if the cache was never updated before.
192	*/
193	public async getLastUpdate(): Promise<Date> {	24✔
194	const lastUpdate = await this.storage.load('contentTypeCacheUpdate');	3✔
195	return lastUpdate;	3✔
196	}
197
198	/**
199	* Checks if the cache is not up to date anymore (update interval exceeded).
200	* @returns true if cache is outdated, false if not
201	*/
202	public async isOutdated(): Promise<boolean> {	24✔
203	log.info(`checking if content type cache is up to date`);	15✔
204	const lastUpdate = await this.storage.load('contentTypeCacheUpdate');	15✔
205	return (	15✔
206	!lastUpdate \|\|	27✔
207	Date.now() - lastUpdate >
208	this.config.contentTypeCacheRefreshInterval
209	);
210	}
211
212	/**
213	* If the running site has already been registered at the H5P hub, this method will
214	* return the UUID of it. If it hasn't been registered yet, it will do so and store
215	* the UUID in the storage object.
216	* @returns uuid
217	*/
218	public async registerOrGetUuid(): Promise<string> {	24✔
219	log.info(	22✔
220	`registering or getting uuid from hub ${this.config.hubRegistrationEndpoint}`
221	);
222	if (this.config.uuid && this.config.uuid !== '') {	22!
UNCOV 223	return this.config.uuid;	×
224	}
225	const response = await axios.post(	22✔
226	this.config.hubRegistrationEndpoint,
227	this.compileRegistrationData()
228	);
229	if (response.status !== 200) {	20!
230	throw new H5pError(	×
231	'error-registering-at-hub',
232	{
233	statusCode: response.status.toString(),
234	statusText: response.statusText
235	},
236	500
237	);
238	}
239	if (!response.data \|\| !response.data.uuid) {	20!
240	throw new H5pError('error-registering-at-hub-no-status', {}, 500);	×
241	}
242	log.debug(`setting uuid to ${response.data.uuid}`);	20✔
243	this.config.uuid = response.data.uuid;	20✔
244	await this.config.save();	40✔
245	return this.config.uuid;	20✔
246	}
247
248	/**
249	* Checks if the interval between updates has been exceeded and updates the cache if necessary.
250	* @returns true if cache was updated, false if not
251	*/
252	public async updateIfNecessary(): Promise<boolean> {	24✔
253	log.info(`checking if update is necessary`);	9✔
254	const oldCache = await this.storage.load('contentTypeCache');	9✔
255	if (!oldCache \|\| (await this.isOutdated())) {	27✔
256	log.info(`update is necessary`);	7✔
257	return (await this.forceUpdate()) !== undefined;	7✔
258	}
259	log.info(`no update necessary`);	2✔
260	return false;	2✔
261	}
262
263	/**
264	* @returns An object with the registration data as required by the H5P Hub
265	*/
266	private compileRegistrationData(): IRegistrationData {	24✔
267	log.debug(	41✔
268	`compiling registration data for hub ${this.config.hubRegistrationEndpoint}`
269	);
270	return {	41✔
271	core_api_version: `${this.config.coreApiVersion.major}.${this.config.coreApiVersion.minor}`,
272	disabled: this.config.fetchingDisabled,
273	h5p_version: this.config.h5pVersion,
274	local_id: ContentTypeCache.generateLocalId(),
275	platform_name: this.config.platformName,
276	platform_version: this.config.platformVersion,
277	type: this.config.siteType,
278	uuid: this.config.uuid
279	};
280	}
281
282	/**
283	* @returns An object with usage statistics as required by the H5P Hub
284	*/
285	private compileUsageStatistics(): IUsageStatistics {	24✔
286	log.info(`compiling usage statistics`);	×
287	return {	×
288	libraries: {}, // TODO: add library information here
289	num_authors: 0 // number of active authors
290	};
291	}
292	}	24✔

Lumieducation / H5P-Nodejs-library / 0978eb06-5436-4a92-9a45-60a3d52c490f

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