@cause-911/core
Version:
Run `npm install @cause-911/core --save` to add this library to your project
1,622 lines (1,604 loc) • 56.5 kB
JavaScript
import { TranslateService, TranslateModule, TranslateLoader, MissingTranslationHandler } from '@ngx-translate/core';
export { TranslateService } from '@ngx-translate/core';
import { InjectionToken, Injectable, Inject, ɵɵdefineInjectable, ɵɵinject, EventEmitter, Output, Component, Injector, NgModule, LOCALE_ID } from '@angular/core';
import { Observable, throwError, of, forkJoin } from 'rxjs';
import { HttpClient, HttpErrorResponse, HttpBackend, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
import { catchError, switchMap, map, retryWhen, scan } from 'rxjs/operators';
import { MatSnackBar } from '@angular/material';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class CoreModuleOptions {
constructor() {
this.apiUrl = '';
this.languages = ['fr', 'en'];
this.loginURL = '/login/';
this.refreshLoginURL = '';
this.allowRefreshToken = false;
this.libraries = [];
this.locale = '';
this.nbRetryOnNetworkError = 0;
this.contentSecurityPolicyActivated = false;
}
}
/** @type {?} */
const CAUSE_CORE_MODULE_OPTIONS = new InjectionToken('cause-core-module-options', {
providedIn: 'root',
factory: CAUSE_CORE_MODULE_OPTIONS_FACTORY,
});
/**
* @return {?}
*/
function CAUSE_CORE_MODULE_OPTIONS_FACTORY() {
return new CoreModuleOptions();
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class Configuration {
/**
* @param {?} options
*/
constructor(options) {
this.libraries = [];
this.loginURL = '';
this.refreshLoginURL = '';
this.allowRefreshToken = true;
this.apiUrl = '';
this.nbRetryOnNetworkError = 0;
this.contentSecurityPolicyActivated = false;
this.useCharset = 'UTF-8';
this.useAuthorizationType = 'Bearer';
this.useAccessToken = '';
this.useRefreshToken = '';
this.useCSRFToken = '';
this.useLocale = options.locale || 'fr';
this.useLanguages = options.languages || ['fr'];
this.libraries = options.libraries || [];
this.apiUrl = options.apiUrl || '/api/';
this.allowRefreshToken = options.allowRefreshToken || true;
this.loginURL = options.loginURL || '/login/';
this.refreshLoginURL = options.refreshLoginURL || '';
this.nbRetryOnNetworkError = options.nbRetryOnNetworkError || 0;
this.contentSecurityPolicyActivated = options.contentSecurityPolicyActivated || false;
}
/**
* @return {?}
*/
get locale() {
return this.useLocale;
}
/**
* @param {?} value
* @return {?}
*/
set locale(value) {
this.useLocale = value;
}
/**
* @return {?}
*/
get languages() {
return this.useLanguages;
}
/**
* @param {?} value
* @return {?}
*/
set languages(value) {
this.useLanguages = value;
this.setDefaultLocale();
}
/**
* @return {?}
*/
get charset() {
return this.useCharset;
}
/**
* @param {?} value
* @return {?}
*/
set charset(value) {
this.useCharset = value;
}
/**
* @return {?}
*/
get authorizationType() {
return this.useAuthorizationType;
}
/**
* @param {?} value
* @return {?}
*/
set authorizationType(value) {
this.useAuthorizationType = value;
}
/**
* @return {?}
*/
get refreshToken() {
if (this.contentSecurityPolicyActivated && !this.useRefreshToken) {
this.useRefreshToken = localStorage.getItem('refreshToken');
}
else if (!this.useRefreshToken) {
this.useRefreshToken = sessionStorage.getItem('refreshToken');
}
return this.useRefreshToken;
}
/**
* @param {?} value
* @return {?}
*/
set refreshToken(value) {
if (this.contentSecurityPolicyActivated) {
localStorage.setItem('refreshToken', value);
}
else {
sessionStorage.setItem('refreshToken', value);
}
this.useRefreshToken = value;
}
/**
* @return {?}
*/
get accessToken() {
if (this.contentSecurityPolicyActivated && !this.useAccessToken) {
this.useAccessToken = localStorage.getItem('accessToken');
}
else if (!this.useAccessToken) {
this.useAccessToken = sessionStorage.getItem('accessToken');
}
return this.useAccessToken;
}
/**
* @param {?} value
* @return {?}
*/
set accessToken(value) {
if (this.contentSecurityPolicyActivated) {
localStorage.setItem('accessToken', value);
}
else {
sessionStorage.setItem('accessToken', value);
}
this.useAccessToken = value;
}
/**
* @return {?}
*/
get CSRFToken() {
if (this.contentSecurityPolicyActivated && !this.useAccessToken) {
this.useCSRFToken = localStorage.getItem('CSRFToken');
}
else if (!this.useCSRFToken) {
this.useCSRFToken = sessionStorage.getItem('CSRFToken');
}
return this.useCSRFToken;
}
/**
* @param {?} value
* @return {?}
*/
set CSRFToken(value) {
if (this.contentSecurityPolicyActivated) {
localStorage.setItem('CSRFToken', value);
}
else {
sessionStorage.setItem('CSRFToken', value);
}
this.useCSRFToken = value;
}
/**
* @private
* @return {?}
*/
setDefaultLocale() {
if (this.useLocale) {
return;
}
if (navigator && navigator.language.indexOf('-') > -1) {
if (this.languages.indexOf(navigator.language) > -1) {
this.locale = navigator.language;
return;
}
const [langue, country] = navigator.language.split('-');
if (this.languages.indexOf(langue) > -1) {
this.locale = langue;
return;
}
}
else if (navigator && navigator.languages.length > 0) {
for (const i in navigator.languages) {
if (this.languages.indexOf(navigator.languages[i]) > -1) {
this.locale = navigator.languages[i];
return;
}
}
}
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class CoreService {
/**
* @param {?} options
* @param {?} translateService
*/
constructor(options, translateService) {
this.translateService = translateService;
this.config = new Configuration(options);
this.config.locale = localStorage.getItem('locale') || this.config.locale || 'fr';
this.config.languages = this.config.languages || ['fr', 'en'];
this.translateService.addLangs(this.config.languages);
this.translateService.setDefaultLang(this.config.locale);
this.translateService.use(this.config.locale);
}
/**
* @return {?}
*/
getConfig() {
return this.config;
}
/**
* @return {?}
*/
toggleLanguage() {
if (this.config.languages.length < 2) {
throw new Error('You need to configure at least two languages.');
}
else if (this.config.languages.length === 2) {
localStorage.setItem('locale', this.config.locale === 'fr' ? 'en' : 'fr');
}
}
}
CoreService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
CoreService.ctorParameters = () => [
{ type: CoreModuleOptions, decorators: [{ type: Inject, args: [CAUSE_CORE_MODULE_OPTIONS,] }] },
{ type: TranslateService }
];
/** @nocollapse */ CoreService.ngInjectableDef = ɵɵdefineInjectable({ factory: function CoreService_Factory() { return new CoreService(ɵɵinject(CAUSE_CORE_MODULE_OPTIONS), ɵɵinject(TranslateService)); }, token: CoreService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class ApiLookupService {
/**
* @param {?} http
*/
constructor(http) {
this.http = http;
this.http = http;
}
/**
* @return {?}
*/
getIpInformation() {
return new Observable((/**
* @param {?} observer
* @return {?}
*/
observer => {
this.lookupIpWith_IpApi().subscribe((/**
* @param {?} result
* @return {?}
*/
result => {
observer.next(result);
observer.complete();
}), (/**
* @return {?}
*/
() => {
this.lookupIpWith_GeoIpDb().subscribe((/**
* @param {?} result
* @return {?}
*/
result => {
observer.next(result);
observer.complete();
}), (/**
* @return {?}
*/
() => {
observer.error('Can\'t lookup the IP address');
}));
}));
}));
}
/**
* @private
* @return {?}
*/
lookupIpWith_GeoIpDb() {
return new Observable((/**
* @param {?} observer
* @return {?}
*/
observer => {
this.http.get('http://geoip-db.com/json').subscribe((/**
* @param {?} response
* @return {?}
*/
response => {
observer.next((/** @type {?} */ ({
country: response['country_code'],
countryName: response['country_name'],
stateName: response['state'],
cityName: response['city'],
longitude: response['longitude'],
latitude: response['latitude']
})));
observer.complete();
}), (/**
* @param {?} error
* @return {?}
*/
error => {
observer.error(error);
}));
}));
}
/**
* @private
* @return {?}
*/
lookupIpWith_IpApi() {
return new Observable((/**
* @param {?} observer
* @return {?}
*/
observer => {
this.http.get('http://ip-api.com/json').subscribe(((/**
* @param {?} response
* @return {?}
*/
response => {
observer.next((/** @type {?} */ ({
country: response['countryCode'],
countryName: response['country'],
state: response['region'],
stateName: response['regionName'],
cityName: response['city'],
isp: response['isp'],
longitude: response['lon'],
latitude: response['lat']
})));
observer.complete();
})), (/**
* @param {?} error
* @return {?}
*/
error => {
observer.error(error);
}));
}));
}
}
ApiLookupService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
ApiLookupService.ctorParameters = () => [
{ type: HttpClient }
];
/** @nocollapse */ ApiLookupService.ngInjectableDef = ɵɵdefineInjectable({ factory: function ApiLookupService_Factory() { return new ApiLookupService(ɵɵinject(HttpClient)); }, token: ApiLookupService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class Browser {
constructor() {
this.browserName = 'unknown';
this.browserVersion = 'unknown';
this.engineName = 'unknown';
this.engineVersion = 'unknown';
this.agent = (typeof (navigator) === 'object' ? navigator.userAgent.toLowerCase() : '');
this.detectBrowser();
this.detectVersion();
}
/**
* @return {?}
*/
toString() {
return `Browser: ${this.browserName} (${this.browserVersion}), Engine: ${this.engineName} (${this.engineVersion})`;
}
/**
* @private
* @return {?}
*/
detectVersion() {
if (this.browserVersion === 'unknown') {
/** @type {?} */
const browserVersion = this.agent.match(this.pattern.browser);
this.browserVersion = (browserVersion ? (browserVersion[2] ? browserVersion[2] : browserVersion[1]) : 'unknown');
}
if (this.engineVersion === 'unknown') {
/** @type {?} */
const engineVersion = this.agent.match(this.pattern.engine);
this.engineVersion = (engineVersion ? engineVersion[1] : 'unknown');
}
}
/**
* @private
* @return {?}
*/
detectBrowser() {
if (this.agent.match(/webkit/)) {
this.detectWebkitBrowser();
}
else if (this.agent.match(/trident|msie/)) {
this.detectTridentBrowser();
}
else if (this.agent.match(/gecko/)) {
this.detectGeckoBrowser();
}
else if (this.agent.match(/presto/)) {
this.pattern = {
browser: /version\/([0-9\.]+)/,
engine: /presto\/([0-9\.]+)/,
};
this.engineName = 'presto';
this.browserName = 'opera';
}
}
/**
* @private
* @return {?}
*/
detectGeckoBrowser() {
this.pattern = {
browser: /gecko\/([0-9\.]+)/,
engine: /rv:([0-9\.]+)/,
};
this.engineName = 'gecko';
if (this.agent.match(/firefox/)) {
this.pattern.browser = /firefox\/([0-9\.]+)/;
this.browserName = 'firefox';
}
}
/**
* @private
* @return {?}
*/
detectTridentBrowser() {
this.pattern = {
browser: /msie ([0-9\.]+)/,
engine: /trident\/([0-9\.]+)/,
};
this.engineName = 'trident';
this.browserName = 'msie';
if (this.agent.match(/rv:/)) { // Internet Explorer 11 et +
this.pattern.browser = /rv:([0-9\.]+)/;
}
else if (!this.agent.match(/msie/)) { // No "rv:" and no "msie", we assume that it's IE 11
this.browserVersion = '11.0';
}
}
/**
* @private
* @return {?}
*/
detectWebkitBrowser() {
this.pattern = {
browser: /webkit\/([0-9\.]+)/,
engine: /applewebkit\/([0-9\.]+)/,
};
this.engineName = 'webkit';
if (this.agent.match(/edge/)) { // Microsoft Edge
this.pattern.browser = /edge\/([0-9\.]+)/;
this.engineName = 'edgeHTML';
this.browserName = 'edge';
}
else if (this.agent.match(/chrome/)) {
// The web engine "blink" is used on many browser (Chrome, Opera, Vivaldi)
this.engineName = 'blink';
if (this.agent.match(/vivaldi/)) { // Vivaldi
this.pattern.browser = /vivaldi\/([0-9\.]+)/;
this.browserName = 'vivaldi';
}
else if (this.agent.match(/opr/)) { // Opera
this.pattern.browser = /opr\/([0-9\.]+)/;
this.browserName = 'opera';
}
else if (this.agent.match(/crios/)) { // Chrome on iOS
this.pattern.browser = /crios\/([0-9\.]+)/;
this.browserName = 'chrome';
}
else { // Chrome
this.pattern.browser = /chrom(e|ium)\/([0-9\.]+)/;
this.browserName = 'chrome';
}
}
else if (this.agent.match(/safari/)) { // Safari
this.pattern.browser = /version\/([0-9\.]+)/;
this.browserName = 'safari';
}
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class OperatingSystem {
constructor() {
this.name = 'unknown';
this.version = 'unknown';
this.agent = (typeof (navigator) === 'object' ? navigator.userAgent.toLowerCase() : '');
this.detect();
}
/**
* @return {?}
*/
toString() {
return `OS: ${this.name} (${this.version})`;
}
/**
* @private
* @return {?}
*/
detect() {
/** @type {?} */
const os = [
{ name: 'iOS', pattern: /iphone|ipad|ipod/ },
{ name: 'Android', pattern: /android/ },
{ name: 'Blackberry', pattern: /blackberry/ },
{ name: 'Windows', pattern: /win/ },
{ name: 'Chrome OS', pattern: /cros/ },
{ name: 'Mac OS', pattern: /mac/ },
{ name: 'Linux', pattern: /linux|x11/ },
{ name: 'Open BSD', pattern: /openbsd/ },
{ name: 'Unix', pattern: /unix/ },
{ name: 'Sun OS', pattern: /sunos/ },
{ name: 'beOS', pattern: /beos/ },
{ name: 'QNX', pattern: /qnx/ },
{ name: 'os2', pattern: /os\/2/ }
];
for (let i = 0, j = os.length; i < j; i++) {
if (this.agent.match(os[i].pattern)) {
this.name = os[i].name;
break;
}
}
this.detectVersion();
}
/**
* @private
* @return {?}
*/
detectVersion() {
if (this.name === 'Windows') {
if (this.agent.match(/phone/)) {
this.detectVersionWindowsPhone();
}
else {
this.detectVersionWindows();
}
}
else if (this.name === 'Mac OS') {
this.detectVersionMac();
}
else if (this.name === 'Android') {
/** @type {?} */
const androidVersion = this.agent.match(/android ([0-9\.]+)/);
this.version = (androidVersion ? ' ' + androidVersion[1] : '');
}
else if (this.name === 'iOS') {
/** @type {?} */
const iOSVersion = this.agent.match(/os ([0-9\_]+)/);
this.version = (iOSVersion ? ' ' + iOSVersion[1].replace('_', '.') : '');
}
}
/**
* @private
* @return {?}
*/
detectVersionWindows() {
this.name = 'Windows';
/** @type {?} */
const windows = [
{ name: '10', pattern: /windows nt 10.0|windows 10.0/ },
{ name: '10 Technical Preview', pattern: /windows nt 6.4/ },
{ name: '8.1', pattern: /windows nt 6.3|windows 8.1/ },
{ name: '8', pattern: /windows nt 6.2|windows 8.0|wow64/ },
{ name: '7 / Server 2008 RC2', pattern: /windows nt 6.1|windows 7/ },
{ name: 'Vista', pattern: /windows nt 6.0/ },
{ name: 'Server 2003', pattern: /windows nt 5.2/ },
{ name: 'XP', pattern: /windows nt 5.1|windows xp/ },
{ name: '2000', pattern: /windows nt 5.0|windows 2000/ },
{ name: 'NT 4.0', pattern: /windows nt 4.0|winnt4.0|winnt|windows nt/ },
{ name: 'CE', pattern: /windows ce/ },
{ name: 'ME', pattern: /windows me/ },
{ name: '98', pattern: /windows 98|win98/ },
{ name: '95', pattern: /windows 95|win95|windows_95/ },
{ name: '3.11', pattern: /win16/ }
];
for (let i = 0, j = windows.length; i < j; i++) {
if (this.agent.match(windows[i].pattern)) {
this.version = windows[i].name;
break;
}
}
}
/**
* @private
* @return {?}
*/
detectVersionWindowsPhone() {
this.name = 'Windows Phone';
/** @type {?} */
const windows = [
{ name: '10', pattern: /windows phone 10/ },
{ name: '8.1', pattern: /windows phone 8.1/ },
{ name: '8', pattern: /windows phone 8/ },
{ name: '7.5', pattern: /windows phone os 7.5/ },
{ name: '7', pattern: /windows phone os 7/ },
];
for (let i = 0, j = windows.length; i < j; i++) {
if (this.agent.match(windows[i].pattern)) {
this.version = windows[i].name;
break;
}
}
}
/**
* @private
* @return {?}
*/
detectVersionMac() {
if (this.agent.match(/mac os x/)) {
/** @type {?} */
const macVersion = this.agent.match(/mac os x ([0-9\_]+)/);
this.name = 'Mac OS X';
this.version = (macVersion ? ' ' + macVersion[1].replace('_', '.') : '');
}
else if (this.agent.match(/macppc|macintel|mac_powerpc|macintosh/)) {
this.name = 'Mac OS';
}
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class ClientInformationService {
/**
* @param {?} coreService
* @param {?} apiLookup
*/
constructor(coreService, apiLookup) {
this.apiLookup = apiLookup;
this.visibilityChange = new EventEmitter();
this.config = coreService.getConfig();
document.addEventListener('visibilitychange webkitvisibilitychange mozvisibilitychange msvisibilitychange', (/**
* @return {?}
*/
() => this.onVisibilityChange(document.visibilityState === 'visible')));
}
/**
* @return {?}
*/
getCoordinates() {
return new Observable((/**
* @param {?} observer
* @return {?}
*/
observer => {
if (navigator && 'geolocation' in navigator) {
navigator.geolocation.getCurrentPosition((/**
* @param {?} position
* @return {?}
*/
position => {
observer.next([
position.coords.longitude,
position.coords.latitude,
]);
observer.complete();
}), (/**
* @return {?}
*/
() => this.getCoordinatesWithClientIP(observer)));
}
else {
this.getCoordinatesWithClientIP(observer);
}
}));
}
/**
* @return {?}
*/
getLanguage() {
return new Observable((/**
* @param {?} observer
* @return {?}
*/
observer => {
/** @type {?} */
let lang = [this.config.locale];
if (navigator && 'languages' in navigator) {
lang = (/** @type {?} */ (navigator.languages));
}
else if (navigator && 'language' in navigator) {
lang = [navigator.language];
}
else if (navigator && 'userLanguage' in navigator) {
lang = [navigator['userLanguage']];
}
observer.next(lang);
observer.complete();
}));
}
/**
* @return {?}
*/
getBrowser() {
return new Observable((/**
* @param {?} observer
* @return {?}
*/
observer => {
/** @type {?} */
const browser = new Browser();
observer.next(browser);
observer.complete();
}));
}
/**
* @return {?}
*/
getOperatingSystem() {
return new Observable((/**
* @param {?} observer
* @return {?}
*/
observer => {
/** @type {?} */
const os = new OperatingSystem();
observer.next(os);
observer.complete();
}));
}
/**
* @private
* @param {?} observer
* @return {?}
*/
getCoordinatesWithClientIP(observer) {
this.apiLookup.getIpInformation().subscribe((/**
* @param {?} info
* @return {?}
*/
info => {
observer.next([
info.longitude,
info.latitude,
]);
observer.complete();
}), (/**
* @return {?}
*/
() => {
observer.next([-71.00, 48.00]);
observer.error('Can\'t find the client location');
}));
}
/**
* @private
* @param {?} visible
* @return {?}
*/
onVisibilityChange(visible) {
this.visibilityChange.emit(visible);
}
}
ClientInformationService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
ClientInformationService.ctorParameters = () => [
{ type: CoreService },
{ type: ApiLookupService }
];
ClientInformationService.propDecorators = {
visibilityChange: [{ type: Output }]
};
/** @nocollapse */ ClientInformationService.ngInjectableDef = ɵɵdefineInjectable({ factory: function ClientInformationService_Factory() { return new ClientInformationService(ɵɵinject(CoreService), ɵɵinject(ApiLookupService)); }, token: ClientInformationService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class FullscreenService {
constructor() {
this.statusChange = new EventEmitter();
document.addEventListener('fullscreenchange webkitfullscreenchange mozfullscreenchange msfullscreenchange', (/**
* @return {?}
*/
() => this.onChange()));
}
/**
* @param {?} element
* @return {?}
*/
show(element) {
if (!element) {
element = document.querySelector('body');
}
if (element.requestFullscreen) {
element.requestFullscreen();
}
else if (element.webkitRequestFullscreen) {
element.webkitRequestFullscreen();
}
else if (element.mozRequestFullScreen) {
element.mozRequestFullScreen();
}
else if (element.msRequestFullscreen) {
element.msRequestFullscreen();
}
}
/**
* @return {?}
*/
exit() {
document.querySelector('body').classList.remove('is-fullscreen');
if (document.exitFullscreen) {
document.exitFullscreen();
}
else if (document['webkitExitFullscreen']) {
document['webkitExitFullscreen']();
}
else if (document['mozCancelFullScreen']) {
document['mozCancelFullScreen']();
}
else if (document['msRequestFullscreen']) {
document['msRequestFullscreen']();
}
}
/**
* @return {?}
*/
isActived() {
if ((screen.availHeight || screen.height - 30) <= window.innerHeight) {
return true;
}
return false;
}
/**
* @private
* @return {?}
*/
onChange() {
if (this.isActived()) {
document.querySelector('body').classList.add('is-fullscreen');
}
else {
document.querySelector('body').classList.remove('is-fullscreen');
}
this.statusChange.emit(this.isActived());
}
}
FullscreenService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
FullscreenService.ctorParameters = () => [];
FullscreenService.propDecorators = {
statusChange: [{ type: Output }]
};
/** @nocollapse */ FullscreenService.ngInjectableDef = ɵɵdefineInjectable({ factory: function FullscreenService_Factory() { return new FullscreenService(); }, token: FullscreenService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class ImageService {
constructor() { }
/**
* @param {?} file
* @param {?=} maxWidth
* @param {?=} maxHeight
* @return {?}
*/
compress(file, maxWidth = 0, maxHeight = 0) {
/** @type {?} */
const fileName = file.name;
/** @type {?} */
const reader = new FileReader();
return new Observable((/**
* @param {?} observer
* @return {?}
*/
(observer) => {
reader.readAsDataURL(file);
reader.onload = (/**
* @param {?} e
* @return {?}
*/
(e) => {
/** @type {?} */
const image = new Image();
image.src = e.target['result'].toString();
image.onload = (/**
* @return {?}
*/
() => {
/** @type {?} */
const ratio = this.findRatio(image, maxWidth, maxHeight);
if (ratio !== null) {
/** @type {?} */
const elem = document.createElement('canvas');
elem.width = ratio.width;
elem.height = ratio.height;
/** @type {?} */
const ctx = elem.getContext('2d');
ctx.drawImage(image, 0, 0, ratio.width, ratio.height);
ctx.canvas.toBlob((/**
* @param {?} blob
* @return {?}
*/
(blob) => {
/** @type {?} */
const resizeFile = new File([blob], fileName, {
type: file.type,
lastModified: Date.now()
});
observer.next(resizeFile);
}), file.type, 1);
}
else {
observer.next(file);
}
});
});
}));
}
/**
* @private
* @param {?} image
* @param {?=} maxWidth
* @param {?=} maxHeight
* @return {?}
*/
findRatio(image, maxWidth = 0, maxHeight = 0) {
if (maxWidth === 0 && maxHeight === 0) {
return null;
}
/** @type {?} */
const aspectRatio = (image.width / image.height);
/** @type {?} */
const aspect = aspectRatio > 1 ? 'horizontal' : 'vertical';
maxWidth = maxWidth || image.width;
maxHeight = maxHeight || image.height;
if (image.width < maxWidth && image.height < maxHeight) {
return null;
}
if (aspect === 'horizontal' && maxWidth < image.width) {
return {
width: maxWidth,
height: (maxWidth / aspectRatio)
};
}
else {
return {
width: (maxHeight * aspectRatio),
height: maxHeight
};
}
}
}
ImageService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
ImageService.ctorParameters = () => [];
/** @nocollapse */ ImageService.ngInjectableDef = ɵɵdefineInjectable({ factory: function ImageService_Factory() { return new ImageService(); }, token: ImageService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class NetworkEstimates {
constructor() {
this.qualities = [{
type: 'GPRS',
minimum: (20 * 1024),
estimate: '50 Kb/s (max estimate)',
}, {
type: 'Regular2G',
minimum: (50 * 1024),
estimate: '250 Kb/s (max estimate)',
}, {
type: 'Good2G',
minimum: (250 * 1024),
estimate: '450 Kb/s (max estimate)',
}, {
type: 'Regular3G',
minimum: (450 * 1024),
estimate: '750 Kb/s (max estimate)',
}, {
type: 'Good3G',
minimum: (750 * 1024),
estimate: '1.5 Mb/s (max estimate)',
}, {
type: 'DSL',
minimum: (1.5 * 1024 * 1024),
estimate: '',
}, {
type: 'Regular4G',
minimum: (3 * 1024 * 1024),
estimate: '4 Mb/s (max estimate)',
}, {
type: 'WIFI',
minimum: (15 * 1024 * 1024),
estimate: '30 Mb/s (min estimate)',
}, {
type: 'Fiber',
minimum: (30 * 1024 * 1024),
estimate: '30 Mb/s (max estimate)',
}, {
type: 'LAN',
minimum: (0.5 * 1024 * 1024 * 1024),
estimate: '500 Mb/s (min estimate)',
}];
}
/**
* @param {?} speedBps
* @return {?}
*/
estimate(speedBps) {
/** @type {?} */
let estimate = '';
this.qualities.forEach((/**
* @param {?} quality
* @return {?}
*/
(quality) => {
if (speedBps > quality.minimum) {
estimate = quality.estimate;
}
}));
return estimate;
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class NetworkInformationService {
constructor() {
this.estimates = new NetworkEstimates();
this.statusChange = new EventEmitter();
window.addEventListener('online', (/**
* @return {?}
*/
() => this.onStatusChange(true)));
window.addEventListener('offline', (/**
* @return {?}
*/
() => this.onStatusChange(false)));
}
/**
* @return {?}
*/
getConnectionSpeed() {
return new Observable((/**
* @param {?} observer
* @return {?}
*/
observer => {
if (navigator && 'connection' in navigator) {
observer.next(`${navigator['connection']['downlink']} Mb/s`);
observer.complete();
}
else {
this.estimateDownlink(observer);
}
}));
}
/**
* @private
* @param {?} observer
* @return {?}
*/
estimateDownlink(observer) {
/** @type {?} */
const startTime = (new Date()).getTime();
/** @type {?} */
const download = new Image();
download.onload = (/**
* @return {?}
*/
() => {
/** @type {?} */
const duration = ((new Date()).getTime() - startTime) / 1000;
/** @type {?} */
const downloadSize = 104857600;
/** @type {?} */
const bitsLoaded = downloadSize * 8;
/** @type {?} */
const speedBps = (bitsLoaded / duration);
observer.next(this.estimates.estimate(speedBps));
observer.complete();
});
download.onerror = (/**
* @param {?} error
* @return {?}
*/
(error) => {
observer.error(error);
});
download.src = 'https://speed.hetzner.de/100MB.bin?_=' + startTime;
}
/**
* @private
* @param {?} online
* @return {?}
*/
onStatusChange(online) {
this.statusChange.emit(online);
}
}
NetworkInformationService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
NetworkInformationService.ctorParameters = () => [];
NetworkInformationService.propDecorators = {
statusChange: [{ type: Output }]
};
/** @nocollapse */ NetworkInformationService.ngInjectableDef = ɵɵdefineInjectable({ factory: function NetworkInformationService_Factory() { return new NetworkInformationService(); }, token: NetworkInformationService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class Color {
/**
* @param {?} h
* @param {?} s
* @param {?} l
* @return {?}
*/
hslToRgb(h, s, l) {
/** @type {?} */
let r;
/** @type {?} */
let g;
/** @type {?} */
let b;
if (s === 0) {
r = g = b = l;
}
else {
/** @type {?} */
const q1 = l < 0.5 ? l * (1 + s) : l + s - l * s;
/** @type {?} */
const p1 = 2 * l - q1;
/** @type {?} */
const hue2rgb = (/**
* @param {?} p2
* @param {?} q2
* @param {?} t
* @return {?}
*/
(p2, q2, t) => {
if (t < 0) {
t += 1;
}
if (t > 1) {
t -= 1;
}
if (t < 1 / 6) {
return p2 + (q2 - p2) * 6 * t;
}
if (t < 1 / 2) {
return q2;
}
if (t < 2 / 3) {
return p2 + (q2 - p2) * (2 / 3 - t) * 6;
}
return p2;
});
r = hue2rgb(p1, q1, h + 1 / 3);
g = hue2rgb(p1, q1, h);
b = hue2rgb(p1, q1, h - 1 / 3);
}
return [Math.floor(r * 255), Math.floor(g * 255), Math.floor(b * 255)];
}
/**
* @param {?} hexcolor
* @return {?}
*/
getContrast50(hexcolor) {
return (parseInt(hexcolor, 16) > 0xffffff / 2) ? 'black' : 'white';
}
/**
* @param {?} hexcolor
* @return {?}
*/
getContrastYIQ(hexcolor) {
/** @type {?} */
const r = parseInt(hexcolor.substr(0, 2), 16);
/** @type {?} */
const g = parseInt(hexcolor.substr(2, 2), 16);
/** @type {?} */
const b = parseInt(hexcolor.substr(4, 2), 16);
/** @type {?} */
const yiq = ((r * 299) + (g * 587) + (b * 114)) / 1000;
return (yiq >= 128) ? 'black' : 'white';
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class PageNotFoundComponent {
constructor() { }
/**
* @return {?}
*/
ngOnInit() {
}
}
PageNotFoundComponent.decorators = [
{ type: Component, args: [{
selector: 'cause-page-not-found',
template: "<div class=\"middle\">\n <h1>Ooops... page not found</h1>\n</div>",
styles: [".middle{max-width:600px;margin:0 auto}.middle h1{text-align:center}"]
}] }
];
/** @nocollapse */
PageNotFoundComponent.ctorParameters = () => [];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class CoreComponent {
constructor() { }
/**
* @return {?}
*/
ngOnInit() {
}
}
CoreComponent.decorators = [
{ type: Component, args: [{
selector: 'cause-core',
template: "<div>{{'core.noGenericComponentOnThisLibrary' | translate}}</div>"
}] }
];
/** @nocollapse */
CoreComponent.ctorParameters = () => [];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class HttpOfflineInterceptor {
constructor() { }
/**
* @param {?} request
* @param {?} next
* @return {?}
*/
intercept(request, next) {
request = request.clone();
if (!navigator.onLine) {
return this.onOffline(new HttpErrorResponse({
headers: request.headers,
status: 408,
statusText: 'Offline',
url: request.url,
}));
}
else {
return next.handle(request).pipe(catchError((/**
* @param {?} error
* @return {?}
*/
error => {
if (error.status === 0) {
return this.onOffline(error);
}
return throwError(error);
})));
}
}
/**
* @private
* @param {?} error
* @return {?}
*/
onOffline(error) {
return throwError(error);
}
}
HttpOfflineInterceptor.decorators = [
{ type: Injectable }
];
/** @nocollapse */
HttpOfflineInterceptor.ctorParameters = () => [];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class HttpTokenWriterInterceptor {
/**
* @param {?} coreService
* @param {?} handler
*/
constructor(coreService, handler) {
this.http = new HttpClient(handler);
this.config = coreService.getConfig();
}
/**
* @param {?} request
* @param {?} next
* @return {?}
*/
intercept(request, next) {
this.requestOriginal = request;
request = request.clone({
headers: this.addSettings(),
});
return next.handle(request).pipe(catchError((/**
* @param {?} error
* @return {?}
*/
error => {
return this.checkIfWeCanManageError(error).pipe(switchMap((/**
* @param {?} handleRequest
* @return {?}
*/
handleRequest => {
request = handleRequest.clone({
headers: this.addSettings(),
});
return next.handle(request);
})), catchError((/**
* @param {?} unhandleError
* @return {?}
*/
unhandleError => {
return throwError(unhandleError);
})));
})));
}
/**
* @private
* @return {?}
*/
addSettings() {
/** @type {?} */
let headers = this.requestOriginal.headers;
/** @type {?} */
const isFormData = this.requestOriginal.body instanceof FormData;
if (!headers.has('Authorization') && this.config.accessToken) {
headers = headers.set('Authorization', `${this.config.authorizationType} ${this.config.accessToken}`);
}
if (!headers.has('X-CSRF-Token') && this.config.CSRFToken) {
headers = headers.set('X-CSRF-Token', `${this.config.CSRFToken}`);
}
if (!headers.has('Content-Type') && !isFormData) {
headers = headers.set('Content-Type', `application/json; charset=${this.config.charset}`);
}
if (!headers.has('Language-Code')) {
headers = headers.set('Language-Code', this.config.locale);
}
return headers;
}
/**
* @private
* @param {?} error
* @return {?}
*/
checkIfWeCanManageError(error) {
if (error.status === 401 && this.config.accessToken && this.config.allowRefreshToken) {
return this.checkRefreshToken().pipe(map((/**
* @param {?} response
* @return {?}
*/
response => {
if (!response) {
location.href = this.config.loginURL;
}
return this.requestOriginal;
})));
}
else if (error.status === 401 && this.config.accessToken) {
location.href = this.config.loginURL;
}
else if (error.status === 200) {
if (error.message && error.message.indexOf('Http failure during parsing for') === 0) {
return of(this.resendAsHTML());
}
}
return throwError(error);
}
/**
* @private
* @return {?}
*/
checkRefreshToken() {
return this.postRefreshToken().pipe(map((/**
* @param {?} data
* @return {?}
*/
data => {
this.config.accessToken = data.accessToken || '';
return data.accessToken ? true : false;
})), catchError((/**
* @param {?} error
* @return {?}
*/
error => {
this.config.accessToken = '';
return of(false);
})));
}
/**
* @private
* @return {?}
*/
postRefreshToken() {
/** @type {?} */
const host = this.config.refreshLoginURL;
/** @type {?} */
let refreshUrl = host;
if (!refreshUrl) {
refreshUrl = `/api/Authentification/Refresh`;
}
/** @type {?} */
const token = (/** @type {?} */ ({
accessToken: this.config.accessToken,
refreshToken: this.config.refreshToken,
}));
return this.http.post(refreshUrl, token);
}
/**
* @private
* @return {?}
*/
resendAsHTML() {
/** @type {?} */
let headers = this.requestOriginal.headers;
headers = headers.set('Content-Type', `text/html; charset=${this.config.charset}`);
return this.requestOriginal.clone({
responseType: 'text',
headers: headers,
});
}
}
HttpTokenWriterInterceptor.decorators = [
{ type: Injectable }
];
/** @nocollapse */
HttpTokenWriterInterceptor.ctorParameters = () => [
{ type: CoreService },
{ type: HttpBackend }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class HttpTokenReaderInterceptor {
/**
* @param {?} coreService
*/
constructor(coreService) {
this.coreService = coreService;
}
/**
* @param {?} request
* @param {?} next
* @return {?}
*/
intercept(request, next) {
return next.handle(request).pipe(map((/**
* @param {?} response
* @return {?}
*/
(response) => {
if (response.headers && response.headers.get('x-csrf-token')) {
this.coreService.getConfig().CSRFToken = response.headers.get('x-csrf-token');
}
return response;
})));
}
}
HttpTokenReaderInterceptor.decorators = [
{ type: Injectable }
];
/** @nocollapse */
HttpTokenReaderInterceptor.ctorParameters = () => [
{ type: CoreService }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
class HttpErrorInterceptor {
/**
* @param {?} injector
*/
constructor(injector) {
this.config = injector.get(CoreService).getConfig();
try {
this.snackBar = injector.get(MatSnackBar);
}
catch (e) {
console.log(`No material snackbar can't be injected. You could "imports" the module "MatSnackBarModule" to use it.`);
}
}
/**
* @param {?} request
* @param {?} next
* @return {?}
*/
intercept(request, next) {
return next.handle(request).pipe(retryWhen((/**
* @param {?} errors
* @return {?}
*/
(errors) => this.handleRetry(errors))), catchError((/**
* @param {?} error
* @return {?}
*/
(error) => this.handleError(error))));
}
/**
* @private
* @param {?} errors
* @return {?}
*/
handleRetry(errors) {
return errors.pipe(scan((/**
* @param {?} accumulator
* @param {?} currentError
* @param {?} errorCount
* @return {?}
*/
(accumulator, currentError, errorCount) => {
/** @type {?} */
const allowNewRetry = (this.config.nbRetryOnNetworkError > 0 && errorCount < this.config.nbRetryOnNetworkError);
/** @type {?} */
const isNetworkError = [0, 408, 502, 503, 504].includes(currentError.status);
if (allowNewRetry && isNetworkError) {
return errorCount + 1;
}
else {
throw currentError;
}
}), 0));
}
/**
* @private
* @param {?} error
* @return {?}
*/
handleError(error) {
if (error instanceof HttpErrorResponse) {
if (error.error instanceof ErrorEvent) {
this.showError(error.error.message);
}
else if (error.status === 0) {
this.showError('La demande ne peut être complétée.');
}
else if (error.