incyclist-services 1.4.18 → 1.4.20

package/lib/activities/upload/velohero.d.ts

@@ -8,6 +8,8 @@ export declare class VeloHeroUpload extends IncyclistService implements IActivit
     constructor();
     init(): boolean;
     isConnected(): boolean;
+    isConnecting(): boolean;
+    disconnect(): void;
     upload(activity: ActivityDetails, format?: string): Promise<boolean>;
     getUrl(id: string): string;
     protected ensureInitialized(): any;

package/lib/activities/upload/velohero.js

@@ -77,6 +77,12 @@ let VeloHeroUpload = (() => {
         isConnected() {
             return this.getVeloHeroAppConnection().isConnected();
         }
+        isConnecting() {
+            return this.getVeloHeroAppConnection().isConnecting();
+        }
+        disconnect() {
+            return this.getVeloHeroAppConnection().disconnect();
+        }
         upload(activity_1) {
             return __awaiter(this, arguments, void 0, function* (activity, format = 'TCX') {
                 var _a;

package/lib/apps/base/api/komoot/api.d.ts

@@ -1,16 +1,18 @@
+import { EventLogger } from 'gd-eventlog';
 import { AppApiBase } from '../base';
 import { KomootAuthConfig, KomootCoordinate, KomootGetTourRequestFilters, KomootGetTourRequestParams, KomootLoginResponse, KomootTourSummary } from './types';
 export declare class KomootApi extends AppApiBase {
     protected username: string;
     protected password: string;
     protected userid: string;
-    protected iid: number;
+    protected logger: EventLogger;
     constructor();
     login(username: string, password: string, userid: string): Promise<KomootLoginResponse>;
     setAuth(auth: KomootAuthConfig | null): void;
     isAuthenticated(): boolean;
     getTours(params?: KomootGetTourRequestParams, filters?: KomootGetTourRequestFilters): Promise<Array<KomootTourSummary>>;
     getTourCoordinates(id: number): Promise<Array<KomootCoordinate>>;
+    protected applyFilter(tours: Array<KomootTourSummary>, filters?: KomootGetTourRequestFilters): KomootTourSummary[];
     protected getBasicAuthCredentials(): {
         username: string;
         password: string;

package/lib/apps/base/api/komoot/api.js

@@ -10,14 +10,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KomootApi = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
 const valid_1 = require("../../../../utils/valid");
 const base_1 = require("../base");
 const API_BASE_URL = 'https://api.komoot.de/v007';
-let IID = 0;
 class KomootApi extends base_1.AppApiBase {
     constructor() {
         super();
-        this.iid = IID++;
+        this.logger = new gd_eventlog_1.EventLogger('KomootAPI');
     }
     login(username, password, userid) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -71,43 +71,73 @@ class KomootApi extends base_1.AppApiBase {
     getTours() {
         return __awaiter(this, arguments, void 0, function* (params = {}, filters) {
             var _a, _b, _c;
-            const auth = this.getBasicAuthCredentials();
-            if (!this.userid)
-                throw new Error('invalid credentials');
-            const keys = Object.keys(params !== null && params !== void 0 ? params : {});
-            const args = keys.map(key => `${key}=${params[key]}`).join('&');
-            const url = keys.length > 0 ? `/users/${this.userid}/tours/?` + args : `/users/${this.userid}/tours/`;
-            const response = yield this.get(url, { auth });
-            if (response.status >= 400 && response.status < 500) {
-                throw new Error('invalid credentials');
+            const tsStart = Date.now();
+            let args;
+            try {
+                const auth = this.getBasicAuthCredentials();
+                if (!this.userid) {
+                    this.logger.logEvent({ message: 'getTours failed', reason: 'invalid credentials' });
+                    throw new Error('invalid credentials');
+                }
+                const keys = Object.keys(params !== null && params !== void 0 ? params : {});
+                args = keys.map(key => `${key}=${params[key]}`).join('&');
+                const url = keys.length > 0 ? `/users/${this.userid}/tours/?` + args : `/users/${this.userid}/tours/`;
+                const response = yield this.get(url, { auth });
+                if (response.status >= 400 && response.status < 500) {
+                    this.logger.logEvent({ message: 'getTours failed', args, reason: 'invalid credentials', duration: Date.now() - tsStart });
+                    throw new Error('invalid credentials');
+                }
+                const tours = (_c = (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a._embedded) === null || _b === void 0 ? void 0 : _b.tours) !== null && _c !== void 0 ? _c : [];
+                const result = this.applyFilter(tours, filters);
+                this.logger.logEvent({ message: 'getTours result', args, tours: result.length, duration: Date.now() - tsStart });
+                return result;
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'getTours failed', args, reason: err.message, duration: Date.now() - tsStart });
+                throw (err);
             }
-            const tours = (_c = (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a._embedded) === null || _b === void 0 ? void 0 : _b.tours) !== null && _c !== void 0 ? _c : [];
-            return tours.filter(tour => {
-                let valid = true;
-                if (filters === null || filters === void 0 ? void 0 : filters.sport)
-                    valid = valid && (tour.sport === filters.sport);
-                if (filters === null || filters === void 0 ? void 0 : filters.after)
-                    valid = valid && (new Date(tour.date).valueOf() > filters.after.valueOf());
-                if (filters === null || filters === void 0 ? void 0 : filters.lastUpdateAfter)
-                    valid = valid && (new Date(tour.changed_at).valueOf() > filters.lastUpdateAfter.valueOf());
-                return valid;
-            });
         });
     }
     getTourCoordinates(id) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
-            const url = `/tours/${id}/coordinates`;
-            const auth = this.getBasicAuthCredentials();
-            const response = yield this.get(url, { auth });
-            if (response.status === 404) {
-                throw new Error('not found');
+            const tsStart = Date.now();
+            try {
+                const url = `/tours/${id}/coordinates`;
+                const auth = this.getBasicAuthCredentials();
+                const response = yield this.get(url, { auth });
+                if (response.status === 404) {
+                    this.logger.logEvent({ message: 'getTourCoordinates failed', id, reason: 'not found', duration: Date.now() - tsStart });
+                    throw new Error('not found');
+                }
+                else if (response.status >= 400 && response.status < 500) {
+                    this.logger.logEvent({ message: 'getTourCoordinates failed', id, reason: 'invalid credentials', duration: Date.now() - tsStart });
+                    throw new Error('invalid credentials');
+                }
+                const points = (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.items) !== null && _b !== void 0 ? _b : [];
+                this.logger.logEvent({ message: 'getTourCoordinates result', id, points: points.length, duration: Date.now() - tsStart });
+                return points;
             }
-            else if (response.status >= 400 && response.status < 500) {
-                throw new Error('invalid credentials');
+            catch (err) {
+                this.logger.logEvent({ message: 'getTourCoordinates failed', id, reason: err.message, duration: Date.now() - tsStart });
+                throw (err);
             }
-            const points = (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.items) !== null && _b !== void 0 ? _b : [];
-            return points;
+        });
+    }
+    applyFilter(tours, filters) {
+        var _a, _b;
+        if (!filters)
+            return tours;
+        const sportTypeFilter = (_b = (_a = filters.sport) === null || _a === void 0 ? void 0 : _a.split(',')) !== null && _b !== void 0 ? _b : [];
+        return tours.filter(tour => {
+            let valid = true;
+            if (filters === null || filters === void 0 ? void 0 : filters.sport)
+                valid = valid && (sportTypeFilter.includes(tour.sport));
+            if (filters === null || filters === void 0 ? void 0 : filters.after)
+                valid = valid && (new Date(tour.date).valueOf() > filters.after.valueOf());
+            if (filters === null || filters === void 0 ? void 0 : filters.lastUpdateAfter)
+                valid = valid && (new Date(tour.changed_at).valueOf() > filters.lastUpdateAfter.valueOf());
+            return valid;
         });
     }
     getBasicAuthCredentials() {

package/lib/apps/base/api/komoot/types.d.ts

@@ -90,4 +90,5 @@ export interface KomootCoordinate extends KomootPoint {
     t: number;
 }
 export type KomootTourType = 'tour_planned' | 'tour_recorded';
-export type KomootSportType = 'hike' | 'touringbicycle' | 'racebike' | 'mtb' | 'jogging' | 'mtb_easy' | 'mtb_advancde' | 'mountaineering';
+export type KomootSportType = 'hike' | 'touringbicycle' | 'mtb' | 'racebike' | 'jogging' | 'mtb_easy' | 'mtb_advancde' | 'mountaineering';
+export type KomootSportTypeNames = 'Hiking' | 'Cycling' | 'Mountain biking' | 'Road cycling' | 'Running' | 'Gravel riding' | 'Enduro mountain biking' | 'Mountaineering';

package/lib/apps/service.d.ts

@@ -24,6 +24,7 @@ export declare class AppsService extends IncyclistService {
     getAppOperationSettings(app: string): any[];
     getConnectedServices(operation: AppsOperation): Array<AppDefinition>;
     getName(key: string): string;
+    getKey(name: string): string;
     protected getAppDisplayProps(key: string): {
         name: string;
         key: string;

package/lib/apps/service.js

@@ -156,6 +156,10 @@ let AppsService = (() => {
             const found = this.serviceMap.find(r => r.key === key);
             return found ? found.name : key;
         }
+        getKey(name) {
+            const found = this.serviceMap.find(r => r.name === name);
+            return found ? found.key : name;
+        }
         getAppDisplayProps(key) {
             const entry = this.serviceMap.find(e => e.key === key);
             const { name, iconUrl } = entry;

package/lib/routes/base/parsers/epm.js

@@ -91,8 +91,6 @@ class EPMParser extends xml_1.XMLParser {
         json.min = reader.ReadUint32();
         json.max = reader.ReadUint32();
         json.cnt = reader.ReadUint32();
-        if (json.cnt !== num) {
-        }
         json.sampleRate = reader.ReadUint32();
         json.validFor = reader.ReadUint32();
         json.elevationStart = reader.ReadFloat();

package/lib/routes/base/types/index.d.ts

@@ -112,6 +112,7 @@ export interface RouteInfo extends RouteBase {
     originalName?: string;
     version?: number;
     source?: string;
+    isLoopVerified?: boolean;
 }
 export type LocalizedText = {
     [index: string]: string;

package/lib/routes/list/cards/ActiveImportCard.d.ts

@@ -6,15 +6,18 @@ import { Route } from "../../base/model/route";
 import { BaseCard } from "./base";
 import { RouteCardType, ActiveImportProps } from "./types";
 import { AppStatus } from "../../base/types";
+import { EventLogger } from "gd-eventlog";
 export declare class ActiveImportCard extends BaseCard implements Card<Route> {
     protected file: FileInfo;
     protected error: Error;
     protected cardObserver: any;
     protected deleteObserver: PromiseObserver<void>;
+    protected logger: EventLogger;
     constructor(file: FileInfo);
     setVisible(): void;
     canStart(status: AppStatus): boolean;
     delete(): PromiseObserver<boolean>;
+    setInitialized(init: boolean): void;
     setError(error: Error): void;
     setData(): void;
     emitUpdate(): void;
@@ -25,4 +28,5 @@ export declare class ActiveImportCard extends BaseCard implements Card<Route> {
     getTitle(): string;
     getDisplayProperties(): ActiveImportProps;
     retry(): void;
+    protected logError(err: Error, fn: string): void;
 }

package/lib/routes/list/cards/ActiveImportCard.js

@@ -5,12 +5,14 @@ const observer_1 = require("../../../base/types/observer");
 const service_1 = require("../service");
 const base_1 = require("./base");
 const types_1 = require("./types");
+const gd_eventlog_1 = require("gd-eventlog");
 class ActiveImportCard extends base_1.BaseCard {
     constructor(file) {
         super();
         this.file = file;
         this.error = null;
         this.cardObserver = new observer_1.Observer();
+        this.logger = new gd_eventlog_1.EventLogger('ActiveImportCard');
     }
     setVisible() {
         this.visible = true;
@@ -26,17 +28,26 @@ class ActiveImportCard extends base_1.BaseCard {
         }
         return observer_1.PromiseObserver.alwaysReturning(true);
     }
+    setInitialized(init) {
+        try {
+            const prev = this.initialized;
+            this.initialized = init;
+            if (init && !prev)
+                this.emitUpdate();
+        }
+        catch (err) {
+            this.logError(err, 'setInitialized');
+        }
+    }
     setError(error) {
         this.error = error;
-        process.nextTick(() => {
-            this.emitUpdate();
-        });
+        process.nextTick(() => { this.emitUpdate(); });
     }
     setData() {
     }
     emitUpdate() {
         const props = this.getDisplayProperties();
-        this.cardObserver.emit('update', props);
+        this.cardObserver.emit('update', Object.assign({}, props));
     }
     getData() {
         return undefined;
@@ -65,5 +76,8 @@ class ActiveImportCard extends base_1.BaseCard {
         this.emitUpdate();
         (0, service_1.useRouteList)().import(this.file, this);
     }
+    logError(err, fn) {
+        this.logger.logEvent({ message: 'error', error: err.message, fn, stack: err.stack });
+    }
 }
 exports.ActiveImportCard = ActiveImportCard;

package/lib/routes/list/cards/RouteCard.d.ts

@@ -92,8 +92,11 @@ export declare class RouteCard extends BaseCard implements Card<Route> {
     changeSettings(props: RouteSettings): void;
     protected adjustStartPosAvi(settings: RouteSettings): void;
     save(): Promise<void>;
-    delete(enforced?: boolean): PromiseObserver<boolean>;
-    protected _delete(enforced?: boolean): Promise<boolean>;
+    delete(props?: {
+        enforced?: boolean;
+        source: 'user' | 'system';
+    }): PromiseObserver<boolean>;
+    protected _delete(enforced?: boolean, source?: 'user' | 'system'): Promise<boolean>;
     start(): void;
     cancel(): void;
     addWorkout(): void;

package/lib/routes/list/cards/RouteCard.js

@@ -338,22 +338,23 @@ class RouteCard extends base_1.BaseCard {
             }
         });
     }
-    delete(enforced) {
+    delete(props) {
+        const { enforced, source = 'user' } = props !== null && props !== void 0 ? props : {};
         try {
             this.logger.logEvent({ message: 'delete card', card: this.getTitle() });
             const service = (0, service_1.getRouteList)();
             service.unselectCard(this);
             if (this.deleteObserver)
                 return this.deleteObserver;
-            this.deleteObserver = new observer_1.PromiseObserver(this._delete(enforced));
+            this.deleteObserver = new observer_1.PromiseObserver(this._delete(enforced, source));
             return this.deleteObserver;
         }
         catch (err) {
             this.logError(err, 'delete');
         }
     }
-    _delete(enforced) {
-        return __awaiter(this, void 0, void 0, function* () {
+    _delete(enforced_1) {
+        return __awaiter(this, arguments, void 0, function* (enforced, source = 'user') {
             yield (0, utils_1.waitNextTick)();
             let deleted = false;
             try {
@@ -384,7 +385,7 @@ class RouteCard extends base_1.BaseCard {
                 this.deleteFromUIList();
                 this.deleteRouteUserSettings();
                 this.logger.logEvent({ message: 'card deleted', card: this.getTitle() });
-                (0, service_1.getRouteList)().emitLists('updated', { log: true });
+                (0, service_1.getRouteList)().emitLists('updated', { log: true, source });
                 deleted = true;
             }
             catch (err) {
@@ -742,6 +743,8 @@ class RouteCard extends base_1.BaseCard {
     }
     verifyRoute(route) {
         var _a, _b;
+        if (route.description.isLoopVerified)
+            return;
         if ((0, route_1.checkIsLoop)(route)) {
             const points = (_b = (_a = route.details) === null || _a === void 0 ? void 0 : _a.points) !== null && _b !== void 0 ? _b : [];
             if (!points.length)
@@ -753,6 +756,7 @@ class RouteCard extends base_1.BaseCard {
             if (Math.abs(slope) > 1) {
                 this.logger.logEvent({ message: 'Loop elevation profile adjusted', route: route.description.title });
                 (0, route_1.updateSlopes)(route.details.points);
+                route.description.isLoopVerified = true;
             }
         }
     }

package/lib/routes/list/service.d.ts

@@ -91,6 +91,8 @@ export declare class RouteListService extends IncyclistService implements IRoute
         observer?: undefined;
         cards?: undefined;
     };
+    getVisibleRoutes(): Array<Route>;
+    getAllAppRoutes(source: string): Array<RouteInfo>;
     searchRepo(requestedFilters?: SearchFilter): {
         routes: SummaryCardDisplayProps[];
         filters: SearchFilter;
@@ -137,27 +139,29 @@ export declare class RouteListService extends IncyclistService implements IRoute
     import(info: FileInfo | Array<FileInfo>, retry?: ActiveImportCard): void;
     emitLists(event: 'loaded' | 'updated', props?: {
         log?: boolean;
+        source?: 'user' | 'system';
     }): void;
     getCard(id: string): RouteCard;
     addCardAgain(card: RouteCard): void;
     protected addImportCard(file: FileInfo): ActiveImportCard;
     protected getFilterContentTypes(): Array<string>;
     protected getFilterRouteTypes(): Array<string>;
+    protected getFilterRouteSources(): Array<string>;
     protected getFilterCountries(): Array<string>;
-    protected addRoute(route: Route): void;
+    protected addRoute(route: Route, source?: 'user' | 'system'): void;
     protected verifyPoints(card: RouteCard, route: Route): Promise<void>;
     protected addFromApi(route: Route): Promise<void>;
-    protected update(route: Route): Promise<void>;
+    protected update(route: Route, source?: 'user' | 'system'): Promise<void>;
     protected loadRoutes(): Promise<void>;
     protected preloadDetails(): Promise<void>;
     protected startSync(): void;
     protected getSyncFrequency(): any;
-    protected checkKomootFeatureEnabled(): any;
     protected stopSync(): void;
     protected performSync(service?: string): Promise<void>;
     protected loadSyncedRouteDetails(route: Route): Promise<Route>;
     protected onSyncRouteAdded(source: string, descriptions: Array<RouteInfo>): void;
     protected onSyncRouteUpdated(source: string, routes: Array<Route>): void;
+    protected onSyncRouteDeleted(source: string, routes: Array<string>): void;
     protected checkUIUpdateWithNoRepoStats(): Promise<void>;
     protected loadRoutesFromRepo(): Promise<void>;
     protected loadRoutesFromApi(): Promise<void>;

package/lib/routes/list/service.js

@@ -103,7 +103,7 @@ let RouteListService = (() => {
             this.db = new db_1.RoutesDbLoader();
             this.createPreviewQueue = [];
             this.routes = [];
-            this.filters = {};
+            this.filters = this.getFilters();
             this.syncInfo = {};
             this.getRouteSyncFactory().setRouteList(this);
             this.handleConfigChanges();
@@ -182,13 +182,16 @@ let RouteListService = (() => {
         saveFilters(requestedFilters) {
             this.filters = requestedFilters;
             const settings = this.getUserSettings();
-            settings.set('preferencs.search.filter', requestedFilters !== null && requestedFilters !== void 0 ? requestedFilters : null);
+            settings.set('preferences.search.filter', requestedFilters !== null && requestedFilters !== void 0 ? requestedFilters : null);
         }
         getFilters() {
-            if (!this.filters) {
-                const settings = this.getUserSettings();
-                this.filters = settings.get('preferencs.search.filter', undefined);
+            try {
+                if (!this.filters) {
+                    const settings = this.getUserSettings();
+                    this.filters = settings.get('preferences.search.filter', undefined);
+                }
             }
+            catch (_a) { }
             return this.filters;
         }
         searchAgain() {
@@ -199,28 +202,39 @@ let RouteListService = (() => {
             if (!this.initialized)
                 this.preload();
             const filters = requestedFilters || this.filters;
-            this.prevFilters = filters;
-            return this.searchRepo(requestedFilters);
+            if (filters !== this.prevFilters) {
+                this.prevFilters = filters;
+                this.saveFilters(filters);
+            }
+            return this.searchRepo(filters);
+        }
+        getVisibleRoutes() {
+            return this.routes.filter(r => r.description && !r.description.isDeleted);
+        }
+        getAllAppRoutes(source) {
+            let routes = this.routes.map(r => r.description);
+            routes = this.applySourceFilter({ routeSource: source }, routes);
+            return routes;
         }
         searchRepo(requestedFilters) {
             if (!this.observer)
                 this.observer = new RouteListObserver_1.RouteListObserver(this);
             try {
-                const filters = requestedFilters || this.filters;
+                const filters = requestedFilters !== null && requestedFilters !== void 0 ? requestedFilters : this.filters;
                 let routes = Array.from(this.getAllSearchCards().map(c => c.getDisplayProperties()));
                 routes.sort((a, b) => a.title > b.title ? 1 : -1);
                 if (!filters) {
                     return { routes, filters, observer: this.observer };
                 }
-                routes = routes.filter(r => filters.includeDeleted || !(r === null || r === void 0 ? void 0 : r.isDeleted));
+                if (!filters.includeDeleted)
+                    routes = routes.filter(r => !(r === null || r === void 0 ? void 0 : r.isDeleted));
                 routes = this.applyTitleFilter(filters, routes);
                 routes = this.applyDistanceFilter(filters, routes);
                 routes = this.applyElevationFilter(filters, routes);
                 routes = this.applyCountryFilter(filters, routes);
                 routes = this.applyContentTypeFilter(filters, routes);
                 routes = this.applyRouteTypeFilter(filters, routes);
-                if (this.checkKomootFeatureEnabled())
-                    routes = this.applySourceFilter(filters, routes);
+                routes = this.applySourceFilter(filters, routes);
                 const cards = routes.map(r => this.getCard(r.id));
                 this.setListTop('list', 0);
                 this.setListTop('tiles', 0);
@@ -260,11 +274,12 @@ let RouteListService = (() => {
         }
         applySourceFilter(filters, routes) {
             routes = routes.filter(r => r.source === undefined || this.getAppsService().isEnabled(r.source, 'RouteDownload'));
-            if (filters.source) {
-                const internal = filters.source === 'none';
-                const sources = filters.source.split('|');
-                routes = routes.filter(r => (r.source === undefined && internal) ||
-                    (r.source === undefined && sources.includes('incyclist')) ||
+            if (filters.routeSource) {
+                const local = filters.routeSource === 'Local';
+                const internal = filters.routeSource === 'Incyclist';
+                const sources = filters.routeSource.split('|').map(s => this.getAppsService().getKey(s));
+                routes = routes.filter(r => (r.source === undefined && !r.isLocal && internal) ||
+                    (r.source === undefined && r.isLocal && local) ||
                     (r.source && !internal && sources.includes(r.source)));
             }
             return routes;
@@ -319,15 +334,17 @@ let RouteListService = (() => {
             let countries = [];
             let contentTypes = [];
             let routeTypes = [];
+            let routeSources = [];
             try {
                 countries = this.getFilterCountries();
                 contentTypes = this.getFilterContentTypes();
                 routeTypes = this.getFilterRouteTypes();
+                routeSources = this.getFilterRouteSources();
             }
             catch (err) {
                 this.logError(err, 'getFilterOption');
             }
-            return { countries, contentTypes, routeTypes };
+            return { countries, contentTypes, routeTypes, routeSources };
         }
         onResize() {
             try {
@@ -439,7 +456,7 @@ let RouteListService = (() => {
         getRouteDetails(id_1) {
             return __awaiter(this, arguments, void 0, function* (id, expectLocal = false) {
                 try {
-                    const route = this.routes.find(r => r.description.id === id);
+                    const route = this.getVisibleRoutes().find(r => r.description.id === id);
                     if (!route)
                         return;
                     if (expectLocal && route.description.requiresDownload && !route.description.isDownloaded) {
@@ -459,7 +476,7 @@ let RouteListService = (() => {
         getRouteDescription(id) {
             var _a;
             try {
-                return (_a = this.routes.find(r => r.description.id === id)) === null || _a === void 0 ? void 0 : _a.description;
+                return (_a = this.getVisibleRoutes().find(r => r.description.id === id)) === null || _a === void 0 ? void 0 : _a.description;
             }
             catch (err) {
                 this.logError(err, 'getRouteDescription', id);
@@ -550,20 +567,19 @@ let RouteListService = (() => {
         emitLists(event, props) {
             var _a;
             try {
+                const { log, source = 'user' } = props !== null && props !== void 0 ? props : {};
                 if (this.currentView === 'grid' || this.currentView === 'list') {
                     const d = this.searchAgain();
-                    this.observer.emit(event, d);
+                    this.observer.emit(event, d, source);
                     return;
                 }
-                const { log } = props !== null && props !== void 0 ? props : {};
                 if (log) {
                     const logs = (_a = this.createRoutesLogEntry(true)) !== null && _a !== void 0 ? _a : {};
                     this.logEvent(Object.assign({ message: `RoutesList ${event}` }, logs));
                 }
                 const lists = this.getLists();
-                const hash = lists ? lists.map(l => l.getCards().map(c => c.getId()).join(',')).join(':') : '';
                 if (this.observer)
-                    this.observer.emit(event, lists, hash);
+                    this.observer.emit(event, lists, source);
             }
             catch (err) {
                 this.logError(err, 'emitLists', event);
@@ -593,10 +609,23 @@ let RouteListService = (() => {
         getFilterRouteTypes() {
             return ['Loop', 'Point to Point'];
         }
+        getFilterRouteSources() {
+            const options = ['Local', 'Incyclist'];
+            this.getVisibleRoutes().forEach(r => {
+                const source = r.description.source;
+                if (!source)
+                    return;
+                const option = this.getAppsService().getName(source);
+                if (option && !options.includes(option)) {
+                    options.push(option);
+                }
+            });
+            return options;
+        }
         getFilterCountries() {
             try {
                 const countries = [];
-                this.routes.forEach(r => {
+                this.getVisibleRoutes().forEach(r => {
                     const iso = r.description.country;
                     let country = 'Unknown';
                     if (iso)
@@ -618,16 +647,21 @@ let RouteListService = (() => {
                 return [];
             }
         }
-        addRoute(route) {
-            var _a;
-            this.logEvent({ message: 'route added', route: route.description.title, source: route.description.source });
+        addRoute(route, source = 'system') {
+            var _a, _b;
+            this.routes.push(route);
             if ((_a = route.description) === null || _a === void 0 ? void 0 : _a.isDeleted)
                 return;
-            if (!route.description.country) {
-                route.updateCountryFromPoints()
-                    .then(() => {
-                    this.db.save(route, false);
-                });
+            if (!((_b = route.description) === null || _b === void 0 ? void 0 : _b.isDeleted)) {
+                if (source === 'user') {
+                    this.logEvent({ message: 'route added', route: route.description.title, source: route.description.source });
+                }
+                if (!route.description.country) {
+                    route.updateCountryFromPoints()
+                        .then(() => {
+                        this.db.save(route, false);
+                    });
+                }
             }
             const list = this.selectList(route);
             const card = new RouteCard_1.RouteCard(route, { list });
@@ -635,8 +669,7 @@ let RouteListService = (() => {
             list.add(card);
             if (list.getId() === 'myRoutes')
                 card.enableDelete(true);
-            this.routes.push(route);
-            this.emitLists('updated');
+            this.emitLists('updated', { source });
         }
         verifyPoints(card, route) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -651,11 +684,11 @@ let RouteListService = (() => {
                 const existing = this.findCard(route);
                 if (existing)
                     return;
-                this.addRoute(route);
+                this.addRoute(route, 'system');
             });
         }
-        update(route) {
-            return __awaiter(this, void 0, void 0, function* () {
+        update(route_2) {
+            return __awaiter(this, arguments, void 0, function* (route, source = 'user') {
                 const existing = this.findCard(route);
                 if (existing)
                     existing.card.updateRoute(route);
@@ -701,8 +734,6 @@ let RouteListService = (() => {
             });
         }
         startSync() {
-            if (!this.checkKomootFeatureEnabled())
-                return;
             try {
                 if (!this.syncInfo.iv) {
                     this.syncInfo.iv = setInterval(() => this.performSync(), this.getSyncFrequency());
@@ -716,10 +747,6 @@ let RouteListService = (() => {
         getSyncFrequency() {
             return this.getUserSettings().get('syncFrequency', SYNC_INTERVAL);
         }
-        checkKomootFeatureEnabled() {
-            const settings = (0, settings_1.useUserSettings)();
-            return settings.get('KOMOOT', false);
-        }
         stopSync() {
             var _a;
             if (!this.syncInfo.iv)
@@ -739,8 +766,10 @@ let RouteListService = (() => {
                     this.syncInfo.observer = observer;
                     const onAdded = this.onSyncRouteAdded.bind(this);
                     const onUpdated = this.onSyncRouteUpdated.bind(this);
+                    const onDeleted = this.onSyncRouteDeleted.bind(this);
                     observer.on('added', onAdded);
                     observer.on('updated', onUpdated);
+                    observer.on('deleted', onDeleted);
                     observer.once('done', () => {
                         delete this.syncInfo.observer;
                         this.observer.emit('sync-done');
@@ -769,7 +798,8 @@ let RouteListService = (() => {
             descriptions.forEach(descr => {
                 const route = new route_1.Route(descr);
                 this.db.save(route);
-                this.addRoute(route);
+                this.addRoute(route, 'system');
+                this.logEvent({ message: 'route added', route: route.description.title, source });
             });
         }
         onSyncRouteUpdated(source, routes) {
@@ -777,7 +807,18 @@ let RouteListService = (() => {
             descriptions.forEach(descr => {
                 const route = new route_1.Route(descr);
                 this.loadSyncedRouteDetails(route);
-                this.update(route);
+                this.update(route, 'system');
+                this.logEvent({ message: 'route updated', route: route.description.title, source });
+            });
+        }
+        onSyncRouteDeleted(source, routes) {
+            routes.forEach(id => {
+                const card = this.getCard(id);
+                if (card) {
+                    card.delete({ source: 'system' });
+                    const description = card.getRouteDescription();
+                    this.logEvent({ message: 'route deleted', route: description === null || description === void 0 ? void 0 : description.title, source });
+                }
             });
         }
         checkUIUpdateWithNoRepoStats() {
@@ -826,6 +867,8 @@ let RouteListService = (() => {
                         yield this.loadSyncedRouteDetails(route);
                     }
                     else {
+                        const target = [{ route, added: false }];
+                        yield this.api.loadDetails(target);
                     }
                 }
                 if (route.description.hasVideo) {
@@ -843,7 +886,7 @@ let RouteListService = (() => {
                     this.db.save(route, false);
                 })
                     .catch(err => {
-                    console.log('# error', route.description.id, route.description.title, err);
+                    this.logError(err, 'verifyRouteCountry', { id: route.description.id, title: route.description.title });
                 });
             }
         }
@@ -993,7 +1036,7 @@ let RouteListService = (() => {
                 const legacyCard = this.myRoutes.getCards().find(c => { var _a, _b; return ((_b = (_a = c.getData()) === null || _a === void 0 ? void 0 : _a.description) === null || _b === void 0 ? void 0 : _b.id) === legacyId; });
                 if (legacyCard) {
                     this.myRoutes.remove(legacyCard);
-                    const idx = this.routes.findIndex(r => r.description.id === legacyId);
+                    const idx = this.routes.findIndex(r => r.description.id === legacyId && !r.description.isDeleted);
                     if (idx !== -1) {
                         this.routes.splice(idx, 1);
                     }

package/lib/routes/list/types.d.ts

@@ -1,4 +1,5 @@
 import { LatLng } from "../../utils/geo";
+import { RouteInfo } from "../base/types";
 import { SummaryCardDisplayProps } from "./cards/RouteCard";
 import { RouteCardType } from "./cards/types";
 export interface RouteStartSettings {
@@ -37,13 +38,14 @@ export interface SearchFilter {
     country?: string;
     contentType?: string;
     routeType?: string;
-    source?: string;
+    routeSource?: string;
     includeDeleted?: boolean;
 }
 export interface SearchFilterOptions {
     countries: Array<string>;
     contentTypes: Array<string>;
     routeTypes: Array<string>;
+    routeSources: Array<string>;
 }
 export interface RoutesRepoUpdates {
     prev?: number;
@@ -58,4 +60,5 @@ export interface IRouteList {
     searchRepo(requestedFilters?: SearchFilter): {
         routes: Array<SummaryCardDisplayProps>;
     };
+    getAllAppRoutes(source: string): Array<RouteInfo>;
 }

package/lib/routes/sync/factory.js

@@ -90,6 +90,7 @@ let RouteSyncFactory = (() => {
                 syncs[service] = so;
                 so.on('added', (info) => observer.emit('added', service, info));
                 so.on('updated', (routes) => observer.emit('updated', service, routes));
+                so.on('deleted', (routes) => observer.emit('deleted', service, routes));
                 so.on('details', (route) => observer.emit('details', service, route));
                 so.on('done', () => {
                     delete syncs[service];

package/lib/routes/sync/komoot/provider.d.ts

@@ -7,6 +7,11 @@ import { RouteInfo, RoutePoint } from "../../base/types";
 import { IRouteList } from "../../list/types";
 import { RouteSyncFactory } from "../factory";
 import { IRouteSyncProvider } from "../types";
+interface SyncModifications {
+    added: Array<KomootTourSummary>;
+    updated: Array<Route>;
+    deleted: Array<string>;
+}
 export declare class KomootSyncProvider extends IncyclistService implements IRouteSyncProvider {
     protected lastSyncTS: number;
     protected observer: Observer;
@@ -18,18 +23,23 @@ export declare class KomootSyncProvider extends IncyclistService implements IRou
     protected getKomootId(route: Route): number;
     protected stopSync(): void;
     protected loadTours(): Promise<Array<KomootTourSummary>>;
-    protected checkTours(tours: Array<KomootTourSummary>): {
-        added: Array<KomootTourSummary>;
-        updated: Array<Route>;
-    };
+    protected emitUpdates(added: KomootTourSummary[], updated: Route[], deleted: string[]): void;
+    protected loadToursFromApi(): Promise<{
+        tours: Array<KomootTourSummary>;
+        done: boolean;
+    }>;
+    protected checkTours(tours: Array<KomootTourSummary>): SyncModifications;
     protected buildRouteInfo(tour: KomootTourSummary): RouteInfo;
     protected adddRouteDetails(route: Route, coordinates: Array<KomootCoordinate>): Promise<void>;
     protected buildRoutePoints(coordinates: KomootCoordinate[], points: RoutePoint[]): RoutePoint[];
     protected emitAdded(tours: Array<KomootTourSummary>): void;
     protected emitUpdated(routes: Array<Route>): void;
+    protected emitDeleted(routes: Array<string>): void;
     protected getLastSyncTime(): Date;
     protected getSportFilter(): string;
+    protected getAvailableSports(): Array<string>;
     protected getCreatedFilter(days?: number): Date;
+    protected updateLastSyncTime(): void;
     protected saveLastSyncTime(): void;
     protected getUserSettings(): import("../../../settings").UserSettingsService;
     protected getRouteListService(): IRouteList;
@@ -38,3 +48,4 @@ export declare class KomootSyncProvider extends IncyclistService implements IRou
     protected getKomootAppConnection(): KomootAppConnection;
     protected getAppsService(): import("../../../apps").AppsService;
 }
+export {};

package/lib/routes/sync/komoot/provider.js

@@ -56,6 +56,14 @@ const geo_1 = require("../../../utils/geo");
 const route_1 = require("../../base/model/route");
 const factory_1 = require("../factory");
 const PAGE_LIMIT = 50;
+const SPORTS_FILTER = 'racebike';
+const sportsOptions = {
+    touringbicycle: 'Cycling',
+    mtb: 'Mountain biking',
+    racebike: 'Road cycling',
+    mtb_easy: 'Gravel riding',
+    mtb_advancde: 'Enduro mountain biking'
+};
 let KomootSyncProvider = (() => {
     var _a;
     let _classSuper = service_1.IncyclistService;
@@ -127,32 +135,48 @@ let KomootSyncProvider = (() => {
                         return [];
                     }
                     this.logEvent({ message: 'start komoot route sync' });
+                    const { tours, done } = yield this.loadToursFromApi();
+                    if (done) {
+                        const { added, updated, deleted } = this.checkTours(tours);
+                        this.updateLastSyncTime();
+                        this.observer.emit('done');
+                        this.logEvent({ message: 'komoot route sync finished', added: added === null || added === void 0 ? void 0 : added.length, updated: updated === null || updated === void 0 ? void 0 : updated.length, deleted: deleted.length });
+                        return added;
+                    }
+                    else {
+                        this.observer.emit('done');
+                        this.logEvent({ message: 'komoot route sync stopped' });
+                        return [];
+                    }
+                });
+            }
+            emitUpdates(added, updated, deleted) {
+                if (added.length > 0) {
+                    this.emitAdded(added);
+                }
+                if (updated.length > 0) {
+                    this.emitUpdated(updated);
+                }
+                if (deleted.length > 0) {
+                    this.emitDeleted(deleted);
+                }
+            }
+            loadToursFromApi() {
+                return __awaiter(this, void 0, void 0, function* () {
                     const api = this.getKomootApi();
                     let page = 0;
                     let done = false;
                     const tours = [];
-                    let cntAdded = 0;
-                    let cntUpdated = 0;
                     while (!done && !this.stopRequested) {
                         try {
-                            const filters = { lastUpdateAfter: this.getLastSyncTime(), sport: this.getSportFilter(), after: this.getCreatedFilter() };
+                            const filters = { sport: this.getSportFilter(), after: this.getCreatedFilter() };
                             const pageTours = yield api.getTours({ type: 'tour_planned', page, limit: PAGE_LIMIT }, filters);
-                            if ((pageTours === null || pageTours === void 0 ? void 0 : pageTours.length) > 0) {
-                                const { added, updated } = this.checkTours(pageTours);
-                                if (added.length > 0) {
-                                    cntAdded += added.length;
-                                    this.emitAdded(added);
-                                    tours.push(...added);
-                                }
-                                if (updated.length > 0) {
-                                    cntUpdated += updated.length;
-                                    this.emitUpdated(updated);
-                                }
+                            if (pageTours.length > 0) {
+                                tours.push(...pageTours);
                                 page++;
                             }
-                            else {
+                            else
                                 done = true;
-                            }
                             yield (0, utils_1.sleep)(100);
                         }
                         catch (err) {
@@ -160,18 +184,13 @@ let KomootSyncProvider = (() => {
                             done = true;
                         }
                     }
-                    if (done) {
-                        this.lastSyncTS = Date.now();
-                        this.saveLastSyncTime();
-                    }
-                    this.logEvent({ message: 'komoot route sync finished', added: cntAdded, updated: cntUpdated });
-                    this.observer.emit('done');
-                    return tours;
+                    return { tours, done };
                 });
             }
             checkTours(tours) {
-                var _b, _c, _d;
-                const routes = (_d = (_c = (_b = this.getRouteListService()) === null || _b === void 0 ? void 0 : _b.searchRepo({ source: 'komoot' })) === null || _c === void 0 ? void 0 : _c.routes) !== null && _d !== void 0 ? _d : [];
+                var _b, _c;
+                const routes = (_c = (_b = this.getRouteListService()) === null || _b === void 0 ? void 0 : _b.getAllAppRoutes('komoot')) !== null && _c !== void 0 ? _c : [];
+                const matched = routes.map(r => ({ id: r.id, matched: false }));
                 const added = [];
                 const updated = [];
                 tours.forEach(tour => {
@@ -181,7 +200,15 @@ let KomootSyncProvider = (() => {
                     if (!route) {
                         added.push(tour);
                     }
+                    else if (route.isDeleted) {
+                        const matchRecord = matched.find(r => r.id === id);
+                        if (matchRecord)
+                            matchRecord.matched = true;
+                    }
                     else {
+                        const matchRecord = matched.find(r => r.id === id);
+                        if (matchRecord)
+                            matchRecord.matched = true;
                         const routeTS = (_b = route.tsLastChange) !== null && _b !== void 0 ? _b : 0;
                         const tourTS = (new Date(tour.changed_at)).valueOf();
                         if (tourTS > routeTS) {
@@ -190,7 +217,10 @@ let KomootSyncProvider = (() => {
                         }
                     }
                 });
-                return { added, updated };
+                const unmatched = matched.filter(r => !r.matched);
+                const deleted = unmatched.map(r => r.id);
+                this.emitUpdates(added, updated, deleted);
+                return { added, updated, deleted };
             }
             buildRouteInfo(tour) {
                 var _b;
@@ -203,7 +233,7 @@ let KomootSyncProvider = (() => {
                     distance: tour.distance,
                     category: 'external',
                     source: 'komoot',
-                    previewUrl: (_b = tour.map_image_preview) === null || _b === void 0 ? void 0 : _b.src,
+                    previewUrl: (_b = tour.vector_map_image_preview) === null || _b === void 0 ? void 0 : _b.src,
                     tsLastChange: (new Date(tour.changed_at)).valueOf()
                 };
                 return info;
@@ -288,6 +318,9 @@ let KomootSyncProvider = (() => {
             emitUpdated(routes) {
                 this.observer.emit('updated', routes);
             }
+            emitDeleted(routes) {
+                this.observer.emit('deleted', routes);
+            }
             getLastSyncTime() {
                 var _b;
                 const lastSyncTS = (_b = this.lastSyncTS) !== null && _b !== void 0 ? _b : 0;
@@ -295,11 +328,19 @@ let KomootSyncProvider = (() => {
                 return this.lastSyncTS > 0 ? new Date(this.lastSyncTS) : undefined;
             }
             getSportFilter() {
-                return 'racebike';
+                return SPORTS_FILTER;
+            }
+            getAvailableSports() {
+                const keys = Object.keys(sportsOptions);
+                return keys.map(sport => sportsOptions[sport]);
             }
             getCreatedFilter(days = 365) {
                 return new Date(Date.now() - days * 24 * 60 * 60 * 1000);
             }
+            updateLastSyncTime() {
+                this.lastSyncTS = Date.now();
+                this.saveLastSyncTime();
+            }
             saveLastSyncTime() {
                 if (!this.lastSyncTS)
                     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.4.18",
+  "version": "1.4.20",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },