6967791a6b69453a29d2588bfdc3db2bce9cb8cc-PR-91

Build # 6967791a6b69453a29d2588bfdc3db2bce9cb8cc-PR-91

Build Type

github

Committed by GitHub

Commit Message

Merge e443e4c4a into d3abb1b7c

Pull Request Pull Request #91: Improve charts partially resolves #80

Run Details

77 of 471 branches covered (16.35%)

Branch coverage included in aggregate %.

15 of 48 new or added lines in 6 files covered. (31.25%)

46 existing lines in 11 files now uncovered.

435 of 992 relevant lines covered (43.85%)

0.92 hits per line

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

18.07

/server/src/services/domain/covid19.ts

import {
    ApiCountriesCovid19Situation,
    ApiCovid19Situation,
    CountrySituationInfo,
} from '../../models/covid19.models';
import { COVID19_FETCH_SALT, TIMES, LogCategory } from '../../models/constants';
import { Country } from '../../models/country.models';
import { fetchCovid19Data } from '../api/api-covid19';
import { CountryLookup } from '../../models/country-code-lookup.models';
import { getCountryByName, getDefaultCountry } from './countryLookup';
import { SubscriptionType } from '../../models/subscription.models';
import { logger } from '../../utils/logger';
import * as TelegramBot from 'node-telegram-bot-api';
import { getCountryNameFormat } from './countries';

// TODO: Improve Cached management
class CachedCovid19CountriesData {
    private subscribers: Array<[Array<SubscriptionType>, Function]> = [];

    public set countriesData(
        countriesData: [number, Array<[Country, Array<CountrySituationInfo>]>]
    ) {
        this.cachedCountriesData = countriesData;

        this.subscribers.forEach(
            ([subscriptionsType, cb]: [Array<SubscriptionType>, Function]) => {
                if (
                    subscriptionsType.some(
                        (subscriptionType: SubscriptionType) =>
                            subscriptionType !==
                            SubscriptionType.TrackCountryUpdates
                    )
                ) {
                    cb(this.countriesData);
                }
            }
        );
    }

    public get countriesData(): [
        number,
        Array<[Country, Array<CountrySituationInfo>]>
    ] {
        return this.cachedCountriesData;
    }

    public set availableCountriesData(countries: Array<Country>) {
        this.cachedAvailableCountriesData = countries;

        this.subscribers.forEach(
            ([subscriptionsType, cb]: [Array<SubscriptionType>, Function]) => {
                if (
                    subscriptionsType.some(
                        (subscriptionType: SubscriptionType) =>
                            subscriptionType ===
                            SubscriptionType.TrackCountryUpdates
                    )
                ) {
                    cb(this.availableCountriesData);
                }
            }
        );
    }

    public get availableCountriesData(): Array<Country> {
        return this.cachedAvailableCountriesData;
    }

    constructor(
        private cachedCountriesData: [
            number,
            Array<[Country, Array<CountrySituationInfo>]>
        ] = [0, []],
        private cachedAvailableCountriesData: Array<Country> = []
    ) {}

    public subscribe(
        cb: Function,
        subscriptionsType: Array<SubscriptionType>
    ): void {
        this.subscribers = [...this.subscribers, [subscriptionsType, cb]];
    }
}

export const cachedCovid19CountriesData = new CachedCovid19CountriesData();

function adaptApiCountriesResponse(
    apiCountriesSituation: ApiCountriesCovid19Situation
): Array<[Country, Array<CountrySituationInfo>]> {
    return Object.entries(apiCountriesSituation).map(
        ([apiCountry, apiSituations]: [string, Array<ApiCovid19Situation>]) => {
            const adaptedCountry: string = getCountryNameFormat(apiCountry);
            const countryLookup: CountryLookup =
                getCountryByName(adaptedCountry) ??
                getDefaultCountry(adaptedCountry);

            const country: Country = {
                name: adaptedCountry,
                region: countryLookup.region,
                continent: countryLookup.continent,
            };

            return [
                country,
                apiSituations.map((situation: ApiCovid19Situation) => ({
                    ...country,
                    ...situation,
                    recovered: situation.recovered ?? 0,
                    deaths: situation.deaths ?? 0,
                    confirmed: situation.confirmed ?? 0,
                })),
            ];
        }
    );
}

function getCovid19Data(): Promise<
    Array<[Country, Array<CountrySituationInfo>]>
> {
    return fetchCovid19Data().then(
        (apiCountriesSituation: ApiCountriesCovid19Situation) => {
            const countriesSituation: Array<[
                Country,
                Array<CountrySituationInfo>
            ]> = adaptApiCountriesResponse(apiCountriesSituation);
            cachedCovid19CountriesData.availableCountriesData = countriesSituation.map(
                ([country]) => country
            );
            cachedCovid19CountriesData.countriesData = [
                Date.now(),
                countriesSituation,
            ];

            return countriesSituation;
        }
    );
}

export function tryToUpdateCovid19Cache(): Promise<TelegramBot.Message> {
    return getCovid19Data()
        .then((v) => undefined)
        .catch((e) =>
            logger.error(
                '[ERROR] While fetching Hopkins uni data',
                e,
                LogCategory.Covid19DataUpdate
            )
        );
}

export function getCountriesSituation(): Promise<
    Array<[Country, Array<CountrySituationInfo>]>
> {
    const [lastFetchedTime, countriesSituation] =
        cachedCovid19CountriesData.countriesData ?? [];

    if (
        lastFetchedTime >
        Date.now() - TIMES.MILLISECONDS_IN_HOUR - COVID19_FETCH_SALT
    ) {
        return Promise.resolve(countriesSituation);
    }

    return getCovid19Data();
}

export function getAvailableCountries(): Promise<Array<Country>> {
    if (!!cachedCovid19CountriesData.availableCountriesData?.length) {
        return Promise.resolve(
            cachedCovid19CountriesData.availableCountriesData
        );
    }

    return getCovid19Data().then(
        (countriesSituation: Array<[Country, Array<CountrySituationInfo>]>) =>
            countriesSituation.map(([country]) => country)
    );
}

1	import {
2	ApiCountriesCovid19Situation,
3	ApiCovid19Situation,
4	CountrySituationInfo,
5	} from '../../models/covid19.models';
6	import { COVID19_FETCH_SALT, TIMES, LogCategory } from '../../models/constants';	2✔
7	import { Country } from '../../models/country.models';
8	import { fetchCovid19Data } from '../api/api-covid19';	2✔
9	import { CountryLookup } from '../../models/country-code-lookup.models';
10	import { getCountryByName, getDefaultCountry } from './countryLookup';	2✔
11	import { SubscriptionType } from '../../models/subscription.models';	2✔
12	import { logger } from '../../utils/logger';	2✔
13	import * as TelegramBot from 'node-telegram-bot-api';
14	import { getCountryNameFormat } from './countries';	2✔
15
16	// TODO: Improve Cached management
17	class CachedCovid19CountriesData {
18	private subscribers: Array<[Array<SubscriptionType>, Function]> = [];	2✔
19
20	public set countriesData(
21	countriesData: [number, Array<[Country, Array<CountrySituationInfo>]>]
22	) {
23	this.cachedCountriesData = countriesData;	×
24
25	this.subscribers.forEach(	×
26	([subscriptionsType, cb]: [Array<SubscriptionType>, Function]) => {
27	if (	×
28	subscriptionsType.some(
29	(subscriptionType: SubscriptionType) =>
30	subscriptionType !==	×
31	SubscriptionType.TrackCountryUpdates
32	)
33	) {
34	cb(this.countriesData);	×
35	}
36	}
37	);
38	}
39
40	public get countriesData(): [
41	number,
42	Array<[Country, Array<CountrySituationInfo>]>
43	] {
44	return this.cachedCountriesData;	×
45	}
46
47	public set availableCountriesData(countries: Array<Country>) {
48	this.cachedAvailableCountriesData = countries;	×
49
50	this.subscribers.forEach(	×
51	([subscriptionsType, cb]: [Array<SubscriptionType>, Function]) => {
52	if (	×
53	subscriptionsType.some(
54	(subscriptionType: SubscriptionType) =>
55	subscriptionType ===	×
56	SubscriptionType.TrackCountryUpdates
57	)
58	) {
59	cb(this.availableCountriesData);	×
60	}
61	}
62	);
63	}
64
65	public get availableCountriesData(): Array<Country> {
UNCOV 66	return this.cachedAvailableCountriesData;	×
67	}
68
69	constructor(
70	private cachedCountriesData: [	2✔
71	number,
72	Array<[Country, Array<CountrySituationInfo>]>
73	] = [0, []],	2✔
74	private cachedAvailableCountriesData: Array<Country> = []	2✔
75	) {}
76
77	public subscribe(
78	cb: Function,
79	subscriptionsType: Array<SubscriptionType>
80	): void {
UNCOV 81	this.subscribers = [...this.subscribers, [subscriptionsType, cb]];	×
82	}
83	}
84
85	export const cachedCovid19CountriesData = new CachedCovid19CountriesData();	2✔
86
87	function adaptApiCountriesResponse(
88	apiCountriesSituation: ApiCountriesCovid19Situation
89	): Array<[Country, Array<CountrySituationInfo>]> {
90	return Object.entries(apiCountriesSituation).map(	×
91	([apiCountry, apiSituations]: [string, Array<ApiCovid19Situation>]) => {
92	const adaptedCountry: string = getCountryNameFormat(apiCountry);	×
93	const countryLookup: CountryLookup =	×
94	getCountryByName(adaptedCountry) ??	×
95	getDefaultCountry(adaptedCountry);
96
97	const country: Country = {	×
98	name: adaptedCountry,
99	region: countryLookup.region,
100	continent: countryLookup.continent,
101	};
102
103	return [	×
104	country,
105	apiSituations.map((situation: ApiCovid19Situation) => ({	×
106	...country,
107	...situation,
108	recovered: situation.recovered ?? 0,	×
109	deaths: situation.deaths ?? 0,	×
110	confirmed: situation.confirmed ?? 0,	×
111	})),
112	];
113	}
114	);
115	}
116
117	function getCovid19Data(): Promise<
118	Array<[Country, Array<CountrySituationInfo>]>
119	> {
UNCOV 120	return fetchCovid19Data().then(	×
121	(apiCountriesSituation: ApiCountriesCovid19Situation) => {
122	const countriesSituation: Array<[
123	Country,
124	Array<CountrySituationInfo>
125	]> = adaptApiCountriesResponse(apiCountriesSituation);	×
126	cachedCovid19CountriesData.availableCountriesData = countriesSituation.map(	×
127	([country]) => country	×
128	);
129	cachedCovid19CountriesData.countriesData = [	×
130	Date.now(),
131	countriesSituation,
132	];
133
134	return countriesSituation;	×
135	}
136	);
137	}
138
139	export function tryToUpdateCovid19Cache(): Promise<TelegramBot.Message> {	2✔
140	return getCovid19Data()	×
141	.then((v) => undefined)	×
142	.catch((e) =>
143	logger.error(	×
144	'[ERROR] While fetching Hopkins uni data',
145	e,
146	LogCategory.Covid19DataUpdate
147	)
148	);
149	}
150
151	export function getCountriesSituation(): Promise<	2✔
152	Array<[Country, Array<CountrySituationInfo>]>
153	> {
154	const [lastFetchedTime, countriesSituation] =	×
155	cachedCovid19CountriesData.countriesData ?? [];	×
156
157	if (	×
158	lastFetchedTime >
159	Date.now() - TIMES.MILLISECONDS_IN_HOUR - COVID19_FETCH_SALT
160	) {
161	return Promise.resolve(countriesSituation);	×
162	}
163
164	return getCovid19Data();	×
165	}
166
167	export function getAvailableCountries(): Promise<Array<Country>> {	2✔
UNCOV 168	if (!!cachedCovid19CountriesData.availableCountriesData?.length) {	×
169	return Promise.resolve(	×
170	cachedCovid19CountriesData.availableCountriesData
171	);
172	}
173
UNCOV 174	return getCovid19Data().then(	×
175	(countriesSituation: Array<[Country, Array<CountrySituationInfo>]>) =>
176	countriesSituation.map(([country]) => country)	×
177	);
178	}

danbilokha / covid19liveupdates / 6967791a6b69453a29d2588bfdc3db2bce9cb8cc-PR-91

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