incyclist-services 1.1.83 → 1.1.85

package/lib/coaches/coach.d.ts

@@ -1,5 +1,30 @@
-import { CoachSettings } from "./types";
+import { EventLogger } from "gd-eventlog";
+import { CoachEditProps, CoachSettings } from "./types";
+import { IncyclistDeviceAdapter } from 'incyclist-devices';
+import { RoutePoint } from "../routes/base/types";
 export declare class Coach {
-    protected settings: CoachSettings;
+    protected _settings: CoachSettings;
+    protected _id: string;
+    protected routeDistance: number;
+    protected riderPosition: number;
+    protected simulator: IncyclistDeviceAdapter;
+    protected logger: EventLogger;
+    protected position: RoutePoint;
     constructor(settings: CoachSettings);
+    get id(): string;
+    get settings(): CoachSettings;
+    get lead(): number;
+    setProgress(routeDistance: number): void;
+    getProgess(): number;
+    setPosition(point: RoutePoint): void;
+    getPosition(): RoutePoint;
+    setRiderPosition(routeDistance: number): void;
+    sendDeviceUpdate(request: any): void;
+    getDisplayProperties(): CoachEditProps;
+    update(settings: CoachEditProps): void;
+    initSimulator(user: {
+        weight: number;
+    }, bikeType: string): void;
+    start(onData: any): Promise<void>;
+    stop(): void;
 }

package/lib/coaches/coach.js

@@ -1,9 +1,108 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Coach = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const incyclist_devices_1 = require("incyclist-devices");
 class Coach {
     constructor(settings) {
-        this.settings = settings;
+        this._settings = settings;
+        this._id = Date.now().toString();
+        this.logger = new gd_eventlog_1.EventLogger('Coach');
+    }
+    get id() {
+        return this._id;
+    }
+    get settings() {
+        return this._settings;
+    }
+    get lead() {
+        const lead = this.routeDistance - this.riderPosition;
+        if (isNaN(lead))
+            return 0;
+        return lead;
+    }
+    setProgress(routeDistance) {
+        this.routeDistance = routeDistance;
+    }
+    getProgess() {
+        return this.routeDistance;
+    }
+    setPosition(point) {
+        this.position = point;
+    }
+    getPosition() {
+        return this.position;
+    }
+    setRiderPosition(routeDistance) {
+        this.riderPosition = routeDistance;
+    }
+    sendDeviceUpdate(request) {
+        if (this.simulator)
+            this.simulator.sendUpdate(request);
+    }
+    getDisplayProperties() {
+        const { name, type, target, lead } = this._settings;
+        const power = type === 'power' ? target : undefined;
+        const speed = type === 'speed' ? target : undefined;
+        const props = {
+            name, type, speed, power, lead
+        };
+        if (this.routeDistance !== undefined && this.riderPosition !== undefined)
+            props.lead = this.lead;
+        return props;
+    }
+    update(settings) {
+        const { name, power, speed, lead } = settings;
+        if (settings.type.toLowerCase() === 'power') {
+            this._settings = { name, type: 'power', target: power, lead };
+            if (!name || name.length === 0 && power !== undefined)
+                this._settings.name = `${power.toFixed(0)}W Coach`;
+        }
+        else if (settings.type.toLowerCase() === 'speed') {
+            this._settings = { name, type: 'speed', target: speed, lead };
+            if (!name || name.length === 0 && speed !== undefined)
+                this._settings.name = `${speed.toFixed(0)}km/h Coach`;
+        }
+    }
+    initSimulator(user, bikeType) {
+        const { type, target } = this.settings;
+        const mode = type === 'power' ? 'Power' : 'Speed';
+        const power = type === 'power' ? target : undefined;
+        const speed = type === 'speed' ? target : undefined;
+        const deviceSettings = { name: this.settings.name, interface: incyclist_devices_1.INTERFACE.SIMULATOR };
+        const props = { port: '', isBot: true, user, settings: { bikeType, mode, power, speed } };
+        if (!this.simulator)
+            this.simulator = incyclist_devices_1.AdapterFactory.create(deviceSettings, props);
+    }
+    start(onData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.simulator)
+                return;
+            try {
+                yield this.simulator.start({});
+                this.simulator.onData((data) => {
+                    onData(this, data);
+                });
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'error', fn: 'startCoach()', coach: this.settings.name, error: err.message || err });
+            }
+        });
+    }
+    stop() {
+        if (!this.simulator)
+            return;
+        this.simulator.stop();
+        this.routeDistance = undefined;
     }
 }
 exports.Coach = Coach;

package/lib/coaches/index.d.ts

@@ -0,0 +1,3 @@
+export * from './service';
+export * from './types';
+export * from './coach';

package/lib/coaches/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./service"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./coach"), exports);

package/lib/coaches/service.d.ts

@@ -1,12 +1,32 @@
 import { IncyclistService } from "../base/service";
+import { Observer } from "../base/types/observer";
+import { DeviceConfigurationService, DevicePairingService, DeviceRideService } from "../devices";
+import { RouteListService } from "../routes";
+import { UserSettingsService } from "../settings";
 import { Coach } from "./coach";
-import { CoachSettings } from "./types";
+import { CoachStatus } from "./types";
+import { IncyclistAdapterData } from "incyclist-devices/lib/types";
 export declare class CoachesService extends IncyclistService {
     protected coaches: Array<Coach>;
+    protected activeRide: Observer;
+    protected isPaused: boolean;
     constructor();
-    openCoachSettings(): void;
-    add(settings: CoachSettings): void;
-    startRide(): void;
+    getCoaches(): Array<Coach>;
+    openCoachEdit(coach?: Coach): Coach;
+    saveCoach(coach: Coach): void;
+    deleteCoach(coach: Coach): void;
+    startRide(): Promise<Observer | null>;
+    stopRide(): Promise<void>;
+    pauseRide(): void;
+    resumeRide(): void;
     updateRiderPosition(routeDistance: number): void;
+    getCoachesRideInfo(): Array<CoachStatus>;
+    protected onCoachDataUpdate(coach: Coach, data: IncyclistAdapterData): void;
+    protected setCoachPosition(coach: Coach, distance: number): void;
+    protected get routesService(): RouteListService;
+    protected get rideService(): DeviceRideService;
+    protected get deviceConfig(): DeviceConfigurationService;
+    protected get pairingService(): DevicePairingService;
+    protected get userService(): UserSettingsService;
 }
 export declare const getCoachesService: () => CoachesService;

package/lib/coaches/service.js

@@ -33,15 +33,31 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCoachesService = exports.CoachesService = void 0;
+const incyclist_devices_1 = require("incyclist-devices");
 const service_1 = require("../base/service");
 const types_1 = require("../base/types");
+const observer_1 = require("../base/types/observer");
+const devices_1 = require("../devices");
+const routes_1 = require("../routes");
+const settings_1 = require("../settings");
+const utils_1 = require("../utils");
 const coach_1 = require("./coach");
+const route_1 = require("../routes/base/utils/route");
 let CoachesService = (() => {
     let _classDecorators = [types_1.Singleton];
     let _classDescriptor;
@@ -52,16 +68,166 @@ let CoachesService = (() => {
         constructor() {
             super('Coaches');
             this.coaches = [];
+            this.isPaused = false;
+        }
+        getCoaches() {
+            return this.coaches;
         }
-        openCoachSettings() {
+        openCoachEdit(coach) {
+            if (coach)
+                return coach;
+            return new coach_1.Coach({ name: '', type: undefined, target: undefined });
         }
-        add(settings) {
-            const coach = new coach_1.Coach(settings);
-            this.coaches.push(coach);
+        saveCoach(coach) {
+            try {
+                const idx = this.coaches.findIndex(c => c.id === coach.id);
+                if (idx !== -1)
+                    this.coaches[idx] = coach;
+                else
+                    this.coaches.push(coach);
+            }
+            catch (err) {
+                this.logError(err, 'saveCoach');
+            }
+        }
+        deleteCoach(coach) {
+            try {
+                const idx = this.coaches.findIndex(c => c.id === coach.id);
+                if (idx !== -1) {
+                    if (this.activeRide) {
+                        coach.stop();
+                    }
+                    this.coaches.splice(idx, 1);
+                }
+            }
+            catch (err) {
+                this.logError(err, 'deleteCoach');
+            }
         }
         startRide() {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (this.activeRide) {
+                        yield this.stopRide();
+                    }
+                    if (!this.coaches)
+                        return null;
+                    this.activeRide = new observer_1.Observer();
+                    this.isPaused = false;
+                    const onDataUpdate = this.onCoachDataUpdate.bind(this);
+                    this.coaches.forEach(c => {
+                        const startSettings = this.routesService.getStartSettings();
+                        let pos = 0;
+                        if (startSettings.type === 'Route') {
+                            pos = startSettings.startPos;
+                        }
+                        c.setProgress(c.settings.lead + pos);
+                        c.setRiderPosition(pos);
+                        this.setCoachPosition(c, c.settings.lead + pos);
+                        const user = this.userService.get('user', {});
+                        const adapter = this.deviceConfig.getSelected(incyclist_devices_1.IncyclistCapability.Control);
+                        const bikeType = adapter.getCyclingMode().getSetting('bikeType') || 'Race';
+                        c.initSimulator(user, bikeType);
+                        c.start(onDataUpdate);
+                    });
+                    (0, utils_1.waitNextTick)().then(() => { this.activeRide.emit('started'); });
+                }
+                catch (err) {
+                    this.logError(err, 'startRide');
+                }
+                return this.activeRide;
+            });
+        }
+        stopRide() {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.coaches.forEach(c => { c.stop(); });
+                    this.isPaused = false;
+                    delete this.activeRide;
+                }
+                catch (err) {
+                    this.logError(err, 'stopRide');
+                }
+            });
+        }
+        pauseRide() {
+            try {
+                this.isPaused = true;
+            }
+            catch (err) {
+                this.logError(err, 'pauseRide');
+            }
+        }
+        resumeRide() {
+            try {
+                this.isPaused = false;
+            }
+            catch (err) {
+                this.logError(err, 'resumeRide');
+            }
         }
         updateRiderPosition(routeDistance) {
+            try {
+                this.coaches.forEach(c => { c.setRiderPosition(routeDistance); });
+            }
+            catch (err) {
+                this.logError(err, 'updateRiderPosition');
+            }
+        }
+        getCoachesRideInfo() {
+            try {
+                const a = [];
+                return a;
+            }
+            catch (err) {
+                this.logError(err, 'resumeRide');
+            }
+        }
+        onCoachDataUpdate(coach, data) {
+            if (this.isPaused)
+                return;
+            const startSettings = this.routesService.getStartSettings();
+            const { distance } = data;
+            const route = this.routesService.getSelected();
+            if (!route || !coach || !data)
+                return;
+            const prevRouteDistance = coach.getProgess();
+            const newRouteDistance = prevRouteDistance + data.distance;
+            coach.setProgress(newRouteDistance);
+            if (startSettings.type === 'Free-Ride')
+                return;
+            this.setCoachPosition(coach, distance);
+        }
+        setCoachPosition(coach, distance) {
+            if (!this.activeRide)
+                return;
+            const startSettings = this.routesService.getStartSettings();
+            const { realityFactor = 0 } = startSettings;
+            const route = this.routesService.getSelected();
+            const prevPosition = coach.getPosition() || route.points[0];
+            let nextPosition = undefined;
+            if (distance > 0) {
+                nextPosition = (0, route_1.getNextPosition)(route, { distance, prev: prevPosition });
+                if (nextPosition) {
+                    const { slope } = nextPosition;
+                    coach.sendDeviceUpdate({ slope: slope * realityFactor / 100 });
+                }
+            }
+        }
+        get routesService() {
+            return (0, routes_1.useRouteList)();
+        }
+        get rideService() {
+            return (0, devices_1.useDeviceRide)();
+        }
+        get deviceConfig() {
+            return (0, devices_1.useDeviceConfiguration)();
+        }
+        get pairingService() {
+            return (0, devices_1.useDevicePairing)();
+        }
+        get userService() {
+            return (0, settings_1.useUserSettings)();
         }
     };
     __setFunctionName(_classThis, "CoachesService");

package/lib/coaches/types.d.ts

@@ -1,13 +1,24 @@
-export type CoachType = 'Speed' | 'Power';
+export type CoachType = 'speed' | 'power';
 export type CoachSettings = {
     name: string;
     type: CoachType;
     target: number;
     lead?: number;
 };
+export type CoachEditProps = {
+    name: string;
+    type: string;
+    power?: number;
+    speed?: number;
+    lead?: number;
+};
 export type CoachStatus = {
     routePosition?: number;
     riderPosition?: number;
     speed?: number;
     power?: number;
+    name: string;
+    avatar: string;
+    lat?: number;
+    lng?: number;
 };

package/lib/devices/ride/service.js

@@ -514,6 +514,8 @@ class DeviceRideService extends events_1.default {
         if (ai.ivToCheck) {
             this.stopHealthCheck(ai);
         }
+        if (ai.adapter.getInterface() === 'simulator')
+            return;
         ai.ivToCheck = (0, timers_1.setInterval)(() => { check(); }, 1000);
         ai.isHealthy = true;
     }

package/lib/index.d.ts

@@ -2,4 +2,5 @@ export * from './devices';
 export * from './utils';
 export * from './api';
 export * from './routes';
+export * from './coaches';
 export { useUserSettings, initUserSettings, UserSettingsService, UserSettingsBinding, IUserSettingsBinding } from './settings';

package/lib/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./devices"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./api"), exports);
 __exportStar(require("./routes"), exports);
+__exportStar(require("./coaches"), exports);
 var settings_1 = require("./settings");
 Object.defineProperty(exports, "useUserSettings", { enumerable: true, get: function () { return settings_1.useUserSettings; } });
 Object.defineProperty(exports, "initUserSettings", { enumerable: true, get: function () { return settings_1.initUserSettings; } });

package/lib/routes/base/utils/route.d.ts

@@ -1,3 +1,4 @@
+import { LatLng } from "../../../utils/geo";
 import { RouteApiDetail } from "../api/types";
 import { Route } from "../model/route";
 import { RoutePoint, RouteSegment } from "../types";
@@ -8,3 +9,21 @@ export declare const validateRoute: (route: RouteApiDetail) => void;
 export declare const getTotalElevation: (route: RouteApiDetail) => number;
 export declare const getTotalDistance: (route: RouteApiDetail) => number;
 export declare const getRouteHash: (route: RouteApiDetail) => string;
+export interface LapPoint extends RoutePoint {
+    lap?: number;
+    totalDistance?: number;
+}
+export interface GetNextPositionProps {
+    routeDistance?: number;
+    distance?: number;
+    prev?: LapPoint;
+}
+export declare const getNextPosition: (route: Route, props: GetNextPositionProps) => any;
+interface GetPositionProps {
+    cnt?: number;
+    distance?: number;
+    nearest?: boolean;
+    latlng?: LatLng;
+}
+export declare const getPosition: (route: Route, props: GetPositionProps) => RoutePoint;
+export {};

package/lib/routes/base/utils/route.js

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRouteHash = exports.getTotalDistance = exports.getTotalElevation = exports.validateRoute = exports.getSegments = exports.updateSlopes = exports.checkIsLoop = void 0;
+exports.getPosition = exports.getNextPosition = exports.getRouteHash = exports.getTotalDistance = exports.getTotalElevation = exports.validateRoute = exports.getSegments = exports.updateSlopes = exports.checkIsLoop = void 0;
 const utils_1 = require("../../../utils");
 const geo_1 = require("../../../utils/geo");
+const valid_1 = require("../../../utils/valid");
 const md5_1 = __importDefault(require("md5"));
 const MAX_LAPMODE_DISTANCE = 50;
 const checkIsLoop = (_route) => {
@@ -142,3 +143,146 @@ const getRouteHash = (route) => {
     return routeHash;
 };
 exports.getRouteHash = getRouteHash;
+const getLapTotalDistance = (route, point) => {
+    const lap = (0, valid_1.valid)(point.lap) ? point.lap : 1;
+    return (lap - 1) * route.description.distance + point.routeDistance;
+};
+const getNextPosition = (route, props) => {
+    var _a;
+    const points = route.points;
+    if (props === undefined) {
+        return;
+    }
+    if (props.distance === undefined && props.routeDistance === undefined) {
+        return;
+    }
+    if (props.routeDistance === undefined && (props.prev === undefined || props.prev.routeDistance === undefined)) {
+        return;
+    }
+    const distance = props.distance !== undefined ? props.distance : props.routeDistance - getLapTotalDistance(route, props.prev);
+    const targetRouteDistance = props.routeDistance !== undefined ? props.routeDistance : getLapTotalDistance(route, props.prev) + distance;
+    let pPrev = props.prev || Object.assign(Object.assign({}, points[0]), { lap: 1 });
+    let point, p;
+    let lap = (0, valid_1.valid)(pPrev.lap) ? pPrev.lap : 1;
+    let cnt = ((_a = props.prev) === null || _a === void 0 ? void 0 : _a.cnt) || 0;
+    let targetRouteInLap;
+    if (route.description.isLoop) {
+        targetRouteInLap = targetRouteDistance % route.description.distance;
+        const prevTargetRouteinLap = props.prev.routeDistance;
+        if (prevTargetRouteinLap > targetRouteInLap) {
+            cnt = 0;
+            lap++;
+        }
+    }
+    else {
+        lap = 1;
+        targetRouteInLap = targetRouteDistance;
+    }
+    for (; cnt < points.length; cnt++) {
+        p = points[cnt];
+        if (p.routeDistance >= targetRouteInLap) {
+            point = Object.assign({}, p);
+            if (pPrev !== undefined) {
+                let pDest;
+                if (pPrev.cnt === point.cnt) {
+                    pDest = utils_1.geo.getPointBetween(props.prev, p, distance);
+                }
+                else {
+                    const distanceToPrev = targetRouteInLap - pPrev.routeDistance;
+                    pDest = utils_1.geo.getPointBetween(pPrev, p, distanceToPrev);
+                    point.cnt = pPrev.cnt;
+                }
+                point.lat = pDest.lat;
+                point.lng = pDest.lng;
+                point.routeDistance = targetRouteInLap;
+                point.distance = point.routeDistance - pPrev.routeDistance;
+                if (route.description.isLoop) {
+                    point.lap = lap;
+                }
+            }
+            return point;
+        }
+        pPrev = p;
+    }
+    return;
+};
+exports.getNextPosition = getNextPosition;
+const getPosition = (route, props) => {
+    if (props === undefined || route.points === undefined)
+        return;
+    const { cnt, distance, nearest = true, latlng } = props;
+    if (props.cnt !== undefined) {
+        return getPointAtIndex(route, cnt);
+    }
+    if (props.distance !== undefined) {
+        return getPointAtDistance(route, distance, nearest);
+    }
+    if (props.latlng !== undefined) {
+        return getPointAtLatLng(route, latlng, nearest);
+    }
+};
+exports.getPosition = getPosition;
+const getPointAtIndex = (route, idx) => {
+    const points = route.points;
+    if (idx >= points.length || idx < 0)
+        return;
+    const point = Object.assign({}, points[idx]);
+    point.cnt = idx;
+    return point;
+};
+const getPointAtDistance = (route, routeDistance, nearest = true) => {
+    const points = route.points;
+    if (!points)
+        return;
+    const exact = !nearest;
+    let cnt = 0;
+    let closestDistance = undefined;
+    let point;
+    points.forEach(p => {
+        if (exact) {
+            if (p.routeDistance === routeDistance) {
+                point = Object.assign({}, p);
+                point.cnt = cnt;
+            }
+        }
+        else {
+            let distance = p.routeDistance - routeDistance;
+            if (distance < 0)
+                distance = distance * -1;
+            if (closestDistance === undefined || distance < closestDistance) {
+                point = Object.assign({}, p);
+                point.cnt = cnt;
+                closestDistance = distance;
+            }
+        }
+        cnt++;
+    });
+    return point;
+};
+const getPointAtLatLng = (route, latlng, nearest = true) => {
+    const points = route.points;
+    if (!points || !route.description.hasGpx)
+        return;
+    const exact = !nearest;
+    let cnt = 0;
+    let closestDistance = undefined;
+    let point;
+    points.forEach(p => {
+        if (exact) {
+            if (p.lat === latlng.lat && p.lng === latlng.lng) {
+                point = Object.assign({}, p);
+                point.cnt = cnt;
+            }
+        }
+        else {
+            const distance = Math.abs(utils_1.geo.calculateDistance(p.lat, p.lng, latlng.lat, latlng.lng));
+            if (closestDistance === undefined || distance < closestDistance) {
+                point = Object.assign({}, p);
+                point.cnt = cnt;
+                closestDistance = distance;
+            }
+        }
+        cnt++;
+    });
+    return point;
+};