incyclist-services 1.3.2 → 1.3.4

package/lib/activities/ride/service.d.ts

@@ -1,15 +1,16 @@
 /// <reference types="node" />
 import { IncyclistService } from "../../base/service";
-import { Observer } from "../../base/types/observer";
+import { Observer, PromiseObserver } from "../../base/types/observer";
 import { DeviceData } from "incyclist-devices";
 import { ExtendedIncyclistCapability, HealthStatus } from "../../devices";
-import { ActivitiesRepository, ActivityDetails, ActivityLogRecord, ActivityRouteType, ScreenShotInfo } from "../base";
+import { ActivitiesRepository, ActivityConverterFactory, ActivityDetails, ActivityLogRecord, ActivityRouteType, ScreenShotInfo } from "../base";
 import { FreeRideStartSettings } from "../../routes/list/types";
 import { RoutePoint } from "../../routes/base/types";
 import { ActivityState } from "./types";
 import { Route } from "../../routes/base/model/route";
 import { ActivityStatsCalculator } from "./stats";
 import { ActivityDuration } from "./duration";
+import { ActivityUploadFactory } from "../upload";
 export declare class ActivityRideService extends IncyclistService {
     protected observer: Observer;
     protected activity: ActivityDetails;
@@ -26,6 +27,8 @@ export declare class ActivityRideService extends IncyclistService {
         routeDistance: number;
         speed: number;
     };
+    protected saveObserver: PromiseObserver<boolean>;
+    protected isSaveDone: boolean;
     protected statsCalculator: ActivityStatsCalculator;
     protected durationCalculator: ActivityDuration;
     protected deviceDataHandler: any;
@@ -47,13 +50,14 @@ export declare class ActivityRideService extends IncyclistService {
     init(id?: string): Observer;
     start(): void;
     stop(): void;
-    private updateActivityTime;
     pause(autoResume?: boolean): void;
     resume(requester?: 'user' | 'system'): void;
     getDashboardDisplayProperties(): any[];
-    getActivitySummaryDisplayProperties(): void;
+    getActivitySummaryDisplayProperties(): {};
     getActivity(): ActivityDetails;
-    save(): Promise<void>;
+    setTitle(title: string): void;
+    delete(): Promise<void>;
+    save(): PromiseObserver<boolean>;
     getObserver(): Observer;
     addSceenshot(screenshot: ScreenShotInfo): void;
     onRouteUpdate(points: Array<RoutePoint>): void;
@@ -64,15 +68,19 @@ export declare class ActivityRideService extends IncyclistService {
     protected _save(): Promise<void>;
     protected getSaveInterval(): number;
     protected updateRepo(): Promise<void>;
+    protected convert(format: string): Promise<boolean>;
+    protected upload(format: string): Promise<boolean>;
     protected getRepo(): ActivitiesRepository;
     protected createLogRecord(): ActivityLogRecord;
     protected createActivity(requestedId?: string): ActivityDetails;
+    protected changeTitle(newTitle: string): void;
     protected updateActivityState(): void;
     protected getTotalDistance(): number;
     protected getTotalElevation(): number;
     protected update(): void;
     protected createFreeRide(settings: FreeRideStartSettings): Route;
     protected getMode(routeType: ActivityRouteType): "video" | "free ride" | "follow route";
+    protected updateActivityTime(): void;
     getRideProps(): any;
     protected logActivityUpdateMessage(): void;
     getBikeInterface(): string;
@@ -83,5 +91,8 @@ export declare class ActivityRideService extends IncyclistService {
     protected getRouteList(): import("../../routes").RouteListService;
     protected getDeviceRide(): import("../../devices").DeviceRideService;
     protected getDeviceConfiguration(): import("../../devices").DeviceConfigurationService;
+    protected getActivityUploadFactory(): ActivityUploadFactory;
+    protected getActivityConverterfactory(): ActivityConverterFactory;
+    protected getFileSystemBinding(): import("../../api/fs").IFileSystem;
 }
 export declare const useActivityRide: () => ActivityRideService;

package/lib/activities/ride/service.js

@@ -63,6 +63,8 @@ const route_1 = require("../../routes/base/utils/route");
 const route_2 = require("../../routes/base/model/route");
 const stats_1 = require("./stats");
 const duration_1 = require("./duration");
+const upload_1 = require("../upload");
+const api_1 = require("../../api");
 const SAVE_INTERVAL = 5000;
 let ActivityRideService = (() => {
     let _classDecorators = [types_1.Singleton];
@@ -115,6 +117,7 @@ let ActivityRideService = (() => {
             this.state = 'active';
             this.tsStart = Date.now();
             this.tsPauseStart = undefined;
+            this.isSaveDone = false;
             this.logEvent({ message: 'activity started' });
             this.startWorker();
             this.emit('started');
@@ -132,13 +135,6 @@ let ActivityRideService = (() => {
             delete this.tsStart;
             (0, utils_1.waitNextTick)().then(() => { delete this.observer; });
         }
-        updateActivityTime() {
-            var _a;
-            if (!this.activity)
-                return;
-            this.activity.timeTotal = (Date.now() - this.tsStart) / 1000;
-            this.activity.time = this.activity.timeTotal - ((_a = this.activity.timePause) !== null && _a !== void 0 ? _a : 0);
-        }
         pause(autoResume = false) {
             if (this.state !== 'active')
                 return;
@@ -164,6 +160,7 @@ let ActivityRideService = (() => {
             this.logEvent({ message: 'activity resumed', requester });
             this.updateActivityTime();
             this._save();
+            this.isSaveDone = false;
         }
         getDashboardDisplayProperties() {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
@@ -229,12 +226,91 @@ let ActivityRideService = (() => {
             }
         }
         getActivitySummaryDisplayProperties() {
+            var _a, _b;
+            try {
+                const route = (0, routes_1.useRouteList)().getSelected();
+                const showSave = this.activity !== undefined && !this.isSaveDone;
+                const showContinue = this.state !== 'completed';
+                const showMap = (_a = route === null || route === void 0 ? void 0 : route.description) === null || _a === void 0 ? void 0 : _a.hasGpx;
+                const preview = showMap ? undefined : (_b = route === null || route === void 0 ? void 0 : route.description) === null || _b === void 0 ? void 0 : _b.previewUrl;
+                const props = {
+                    activity: this.activity,
+                    showSave,
+                    showContinue,
+                    showMap,
+                    preview
+                };
+                return props;
+            }
+            catch (err) {
+                this.logError(err, 'getActivitySummaryDisplayProperties()');
+                return {};
+            }
         }
         getActivity() {
             return this.activity;
         }
+        setTitle(title) {
+            this.activity.title = title;
+            this._save();
+        }
+        delete() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.state === 'idle' || !this.observer)
+                    return;
+                if (this.state !== 'completed') {
+                    this.stop();
+                    yield new Promise(done => { this.observer.on('completed', done); });
+                }
+                this.getRepo().delete(this.activity.id);
+                this.state = 'idle';
+            });
+        }
         save() {
-            return this._save();
+            console.log('~~~ ActivityRide.save', this.saveObserver !== undefined, this.isSaveDone);
+            if (this.saveObserver) {
+                return this.saveObserver;
+            }
+            const emit = (event, ...args) => {
+                if (this.saveObserver)
+                    this.saveObserver.emit(event, ...args);
+                console.log('~~~ ActivityRide.emit', event, args, this.saveObserver !== undefined, this.isSaveDone);
+            };
+            const run = () => __awaiter(this, void 0, void 0, function* () {
+                let success = false;
+                try {
+                    emit('start', success);
+                    yield this._save();
+                    let format = undefined;
+                    let uploadSuccess = false;
+                    let convertSuccess = yield this.convert('TCX');
+                    if (convertSuccess) {
+                        format = 'TCX';
+                        this.convert('FIT');
+                    }
+                    else {
+                        convertSuccess == (yield this.convert('FIT'));
+                        if (convertSuccess)
+                            format = 'FIT';
+                    }
+                    if (convertSuccess) {
+                        uploadSuccess = yield this.upload(format);
+                    }
+                    success = convertSuccess && uploadSuccess;
+                    this.isSaveDone = true;
+                }
+                catch (err) {
+                    success = false;
+                }
+                emit('done', success);
+                (0, utils_1.waitNextTick)().then(() => {
+                    delete this.saveObserver;
+                });
+                return success;
+            });
+            this.saveObserver = new observer_1.PromiseObserver(run());
+            console.log('~~~ ActivityRide.save returns', this.saveObserver !== undefined, this.isSaveDone);
+            return this.saveObserver;
         }
         getObserver() {
             if (this.state === 'idle')
@@ -267,6 +343,8 @@ let ActivityRideService = (() => {
         onDeviceData(data) {
             if (!this.current)
                 return;
+            if (!data)
+                return;
             try {
                 this.current.tsDeviceData = Date.now();
                 const update = Object.assign({}, data);
@@ -332,6 +410,60 @@ let ActivityRideService = (() => {
                 }
             });
         }
+        convert(format) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const emit = (event, ...args) => {
+                    if (this.saveObserver)
+                        this.saveObserver.emit(event, ...args);
+                    else {
+                        try {
+                            throw new Error('');
+                        }
+                        catch (err) {
+                            console.log('~~~ WARN: emitting on non existing observer', event.args, err.stack);
+                        }
+                    }
+                };
+                const fs = this.getFileSystemBinding();
+                emit('convert.start', format);
+                try {
+                    let data;
+                    data = yield base_1.ActivityConverter.convert(this.activity, format);
+                    emit('convert.done', format, true);
+                    if (format.toLowerCase() === 'fit') {
+                        const fileName = this.activity.fileName.replace('json', 'fit');
+                        yield fs.writeFile(fileName, Buffer.from(data));
+                        this.activity.fitFileName = fileName;
+                    }
+                    if (format.toLowerCase() === 'tcx') {
+                        const fileName = this.activity.fileName.replace('json', 'tcx');
+                        yield fs.writeFile(fileName, Buffer.from(data));
+                        this.activity.tcxFileName = fileName;
+                    }
+                    yield this._save();
+                    return true;
+                }
+                catch (err) {
+                    emit('convert.error', format, err);
+                    return false;
+                }
+            });
+        }
+        upload(format) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const factory = this.getActivityUploadFactory();
+                this.saveObserver.emit('upload.start', format);
+                try {
+                    yield factory.upload(this.activity, format.toLowerCase());
+                    this.saveObserver.emit('upload.done', format, true);
+                    return true;
+                }
+                catch (err) {
+                    this.saveObserver.emit('upload.error', format, err);
+                    return false;
+                }
+            });
+        }
         getRepo() {
             if (this.repo)
                 return this.repo;
@@ -436,6 +568,11 @@ let ActivityRideService = (() => {
             };
             return activity;
         }
+        changeTitle(newTitle) {
+            if (!(newTitle === null || newTitle === void 0 ? void 0 : newTitle.length))
+                return;
+            this.activity.title = newTitle;
+        }
         updateActivityState() {
             var _a, _b;
             if (this.state !== 'active')
@@ -451,7 +588,7 @@ let ActivityRideService = (() => {
                 this.current.routeDistance += distance;
                 if (distance !== 0) {
                     const prev = this.current.position;
-                    const position = (_b = (0, route_1.getNextPosition)(this.current.route, { distance, prev: this.current.position })) !== null && _b !== void 0 ? _b : (0, route_1.getNextPosition)(this.current.route, { routeDistance: this.current.routeDistance });
+                    const position = (_b = (0, route_1.getNextPosition)(this.current.route, { routeDistance: this.current.routeDistance, prev: this.current.position })) !== null && _b !== void 0 ? _b : (0, route_1.getNextPosition)(this.current.route, { distance, prev: this.current.position });
                     this.current.position = position !== null && position !== void 0 ? position : prev;
                     if (this.activity.realityFactor > 0) {
                         const gain = (0, route_1.getElevationGainAt)(this.current.route, this.current.routeDistance);
@@ -555,6 +692,13 @@ let ActivityRideService = (() => {
                 return 'follow route';
             return 'free ride';
         }
+        updateActivityTime() {
+            var _a;
+            if (!this.activity)
+                return;
+            this.activity.timeTotal = (Date.now() - this.tsStart) / 1000;
+            this.activity.time = this.activity.timeTotal - ((_a = this.activity.timePause) !== null && _a !== void 0 ? _a : 0);
+        }
         getRideProps() {
             var _a;
             const { startPos, realityFactor, routeType } = this.activity;
@@ -613,6 +757,15 @@ let ActivityRideService = (() => {
         getDeviceConfiguration() {
             return (0, devices_1.useDeviceConfiguration)();
         }
+        getActivityUploadFactory() {
+            return new upload_1.ActivityUploadFactory();
+        }
+        getActivityConverterfactory() {
+            return new base_1.ActivityConverterFactory();
+        }
+        getFileSystemBinding() {
+            return (0, api_1.getBindings)().fs;
+        }
     };
     __setFunctionName(_classThis, "ActivityRideService");
     (() => {

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

@@ -0,0 +1,8 @@
+import { ActivityDetails } from "../base";
+import { IActivityUpload, UploaderInfo } from "./types";
+export declare class ActivityUploadFactory {
+    protected uploaders: Array<UploaderInfo>;
+    constructor();
+    add(service: string, uploader: IActivityUpload): void;
+    upload(activity: ActivityDetails, format?: string): Promise<any[]>;
+}

package/lib/activities/upload/factory.js

@@ -0,0 +1,98 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    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.ActivityUploadFactory = void 0;
+const types_1 = require("../../base/types");
+let ActivityUploadFactory = (() => {
+    let _classDecorators = [types_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var ActivityUploadFactory = _classThis = class {
+        constructor() {
+            this.uploaders = [];
+        }
+        add(service, uploader) {
+            const existing = this.uploaders.findIndex(ui => ui.service === service);
+            if (existing === -1)
+                this.uploaders.push({ service, uploader });
+            else
+                this.uploaders[existing] = { service, uploader };
+        }
+        upload(activity_1) {
+            return __awaiter(this, arguments, void 0, function* (activity, format = 'TCX') {
+                const uploads = [];
+                this.uploaders.forEach(ui => {
+                    const { service, uploader } = ui;
+                    if (uploader.isConnected()) {
+                        const promise = uploader.upload(activity, format)
+                            .then(success => ({ service, success }))
+                            .catch(err => ({ service, success: false, error: err.message }));
+                        uploads.push({ service, promise, status: undefined });
+                    }
+                });
+                if (uploads.length > 0) {
+                    const result = yield Promise.allSettled(uploads.map(us => us.promise));
+                }
+                else
+                    return [];
+            });
+        }
+    };
+    __setFunctionName(_classThis, "ActivityUploadFactory");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        ActivityUploadFactory = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return ActivityUploadFactory = _classThis;
+})();
+exports.ActivityUploadFactory = ActivityUploadFactory;

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

@@ -1,2 +1,4 @@
 export * from './velohero';
+export * from './strava';
 export * from './types';
+export * from './factory';

package/lib/activities/upload/index.js

@@ -14,5 +14,13 @@ 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 });
+const factory_1 = require("./factory");
+const strava_1 = require("./strava");
+const velohero_1 = require("./velohero");
 __exportStar(require("./velohero"), exports);
+__exportStar(require("./strava"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./factory"), exports);
+const factory = new factory_1.ActivityUploadFactory();
+factory.add('strava', new strava_1.StravaUpload());
+factory.add('velohero', new velohero_1.VeloHeroUpload());

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

@@ -0,0 +1,24 @@
+import { IncyclistService } from "../../base/service";
+import { ActivityDetails } from "../base";
+import { StravaApi, StravaConfig, StravaFormat } from "../../apps/base/api/strava";
+import { IActivityUpload } from "./types";
+export declare class StravaUpload extends IncyclistService implements IActivityUpload {
+    protected isInitialized: any;
+    protected api: StravaApi;
+    protected config: StravaConfig;
+    protected _isConnecting: any;
+    constructor();
+    init(): boolean;
+    isConnected(): boolean;
+    isConnecting(): boolean;
+    connect(accessToken: string, refreshToken: string, expiration?: Date): Promise<boolean>;
+    disconnect(): void;
+    upload(activity: ActivityDetails, format?: string): Promise<boolean>;
+    protected getStravaFormat(format: string): StravaFormat;
+    protected getCredentials(): any;
+    protected saveCredentials(): void;
+    protected updateConfig(config: StravaConfig): void;
+    protected getSecret(key: string): string;
+    protected getUserSettings(): import("../../settings").UserSettingsService;
+    protected getApi(): StravaApi;
+}