incyclist-services 1.3.2 → 1.3.3

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,7 @@ export declare class ActivityRideService extends IncyclistService {
         routeDistance: number;
         speed: number;
     };
+    protected saveObserver: PromiseObserver<boolean>;
     protected statsCalculator: ActivityStatsCalculator;
     protected durationCalculator: ActivityDuration;
     protected deviceDataHandler: any;
@@ -47,13 +49,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;
     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,6 +67,8 @@ 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;
@@ -73,6 +78,7 @@ export declare class ActivityRideService extends IncyclistService {
     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 +89,7 @@ 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;
 }
 export declare const useActivityRide: () => ActivityRideService;

package/lib/activities/ride/service.js

@@ -63,6 +63,7 @@ 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 SAVE_INTERVAL = 5000;
 let ActivityRideService = (() => {
     let _classDecorators = [types_1.Singleton];
@@ -132,13 +133,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;
@@ -233,8 +227,63 @@ let ActivityRideService = (() => {
         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();
+            if (this.saveObserver) {
+                return this.saveObserver;
+            }
+            const emit = (event, ...args) => {
+                if (this.saveObserver)
+                    this.saveObserver.emit(event, ...args);
+            };
+            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;
+                }
+                catch (err) {
+                    success = false;
+                }
+                emit('done', success);
+                (0, utils_1.waitNextTick)().then(() => {
+                    delete this.saveObserver;
+                });
+                return success;
+            });
+            this.saveObserver = new observer_1.PromiseObserver(run());
+            return this.saveObserver;
         }
         getObserver() {
             if (this.state === 'idle')
@@ -267,6 +316,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 +383,40 @@ let ActivityRideService = (() => {
                 }
             });
         }
+        convert(format) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.saveObserver.emit('convert.start', format);
+                try {
+                    base_1.ActivityConverter.convert(this.activity, format);
+                    this.saveObserver.emit('convert.done', format, true);
+                    if (format.toLowerCase() === 'fit')
+                        this.activity.fitFileName = this.activity.fileName.replace('json', 'fit');
+                    if (format.toLowerCase() === 'tcx')
+                        this.activity.tcxFileName = this.activity.fileName.replace('json', 'tcx');
+                    yield this._save();
+                    return true;
+                }
+                catch (err) {
+                    this.saveObserver.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');
+                try {
+                    yield factory.upload(this.activity, format);
+                    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;
@@ -451,7 +536,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 +640,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 +705,12 @@ let ActivityRideService = (() => {
         getDeviceConfiguration() {
             return (0, devices_1.useDeviceConfiguration)();
         }
+        getActivityUploadFactory() {
+            return new upload_1.ActivityUploadFactory();
+        }
+        getActivityConverterfactory() {
+            return new base_1.ActivityConverterFactory();
+        }
     };
     __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;
+}

package/lib/activities/upload/strava.js

@@ -0,0 +1,252 @@
+"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.StravaUpload = void 0;
+const service_1 = require("../../base/service");
+const types_1 = require("../../base/types");
+const settings_1 = require("../../settings");
+const valid_1 = require("../../utils/valid");
+const strava_1 = require("../../apps/base/api/strava");
+const api_1 = require("../../api");
+let StravaUpload = (() => {
+    let _classDecorators = [types_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = service_1.IncyclistService;
+    var StravaUpload = _classThis = class extends _classSuper {
+        constructor() {
+            super('StravaUpload');
+            this.isInitialized = false;
+            this.init();
+        }
+        init() {
+            if (this.isInitialized)
+                return true;
+            if (!this.getUserSettings().isInitialized)
+                return false;
+            try {
+                const clientId = this.getSecret('STRAVA_CLIENT_ID');
+                const clientSecret = this.getSecret('STRAVA_CLIENT_SECRET');
+                const auth = this.getCredentials();
+                if (clientId && clientSecret && auth) {
+                    this.logger.logEvent({ message: 'Strava init done', hasCredentials: true });
+                    this.config = {
+                        clientId, clientSecret,
+                        accessToken: auth.accesstoken,
+                        refreshToken: auth.refreshtoken,
+                        expiration: new Date(auth.expiration)
+                    };
+                    const observer = this.getApi().init(this.config);
+                    observer.on('token.updated', this.updateConfig.bind(this));
+                }
+                else {
+                    this.logger.logEvent({ message: 'Strava init done', hasCredentials: false });
+                }
+                this.isInitialized = true;
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'error', error: err.message, fn: 'init', stack: err.stack });
+                this.isInitialized = false;
+            }
+            return this.isInitialized;
+        }
+        isConnected() {
+            if (!this.isInitialized) {
+                this.init();
+            }
+            return ((0, valid_1.valid)(this.config));
+        }
+        isConnecting() {
+            return false;
+        }
+        connect(accessToken, refreshToken, expiration) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.isInitialized) {
+                    const ok = this.init();
+                }
+                this.logger.logEvent({ message: 'Connect with Strava' });
+                try {
+                    const isConnected = this.isConnected();
+                    const config = {
+                        clientId: this.getSecret('STRAVA_CLIENT_ID'),
+                        clientSecret: this.getSecret('STRAVA_CLIENT_SECRET'),
+                        accessToken, refreshToken, expiration
+                    };
+                    if (isConnected) {
+                        this.getApi().update(this.config);
+                    }
+                    else {
+                        const observer = this.getApi().init(this.config);
+                        observer.on('token.updated', this.updateConfig.bind(this));
+                    }
+                    yield this.saveCredentials();
+                    this.logger.logEvent({ message: 'Connect with strava success' });
+                    return true;
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'Connect with Strava failed', error: err.message });
+                    throw err;
+                }
+            });
+        }
+        disconnect() {
+            if (!this.isInitialized) {
+                const ok = this.init();
+            }
+            try {
+                this.getUserSettings().set('user.auth.strava', null);
+                this.config = undefined;
+                this.getApi().init(undefined);
+            }
+            catch (err) {
+                this.logError(err, 'disconnect');
+            }
+        }
+        upload(activity_1) {
+            return __awaiter(this, arguments, void 0, function* (activity, format = 'TCX') {
+                try {
+                    if (!this.isInitialized) {
+                        const ok = this.init();
+                        if (!ok)
+                            return false;
+                    }
+                    if (!this.isConnected())
+                        return false;
+                    this.logger.logEvent({ message: 'Strava Upload', format });
+                    const fileName = activity[`${format}FileName`];
+                    const res = yield this.getApi().upload(fileName, {
+                        name: activity.name,
+                        description: '',
+                        format: this.getStravaFormat(format)
+                    });
+                    this.logger.logEvent({ message: 'Strava Upload success', activityId: res.stravaId });
+                    return true;
+                }
+                catch (err) {
+                    if (err instanceof strava_1.DuplicateError) {
+                        this.logger.logEvent({ message: 'Strava Upload failure', error: 'duplicate', activityId: err.stravaId });
+                    }
+                    else {
+                        this.logger.logEvent({ message: 'Strava Upload failure', error: err.message });
+                    }
+                    return false;
+                }
+            });
+        }
+        getStravaFormat(format) {
+            switch (format.toLowerCase()) {
+                case 'tcx':
+                    return 'tcx';
+                case 'fit':
+                    return 'fit';
+                case 'gox':
+                    return 'gpx';
+                default:
+                    return null;
+            }
+        }
+        getCredentials() {
+            const userSettings = this.getUserSettings();
+            try {
+                return userSettings.get('user.auth.strava', null);
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        saveCredentials() {
+            this.logger.logEvent({ message: 'Strava Save Credentials' });
+            try {
+                if (!this.isConnected()) {
+                    this.getUserSettings().set('user.auth.strava', null);
+                    return;
+                }
+                this.getUserSettings().set('user.auth.strava', {
+                    accesstoken: this.config.accessToken,
+                    refreshToken: this.config.refreshToken,
+                    expiration: this.config.expiration.toUTCString()
+                });
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'error', fn: 'saveCredentials', error: err.message, stack: err.stack });
+            }
+            this.logger.logEvent({ message: 'Strava Save Credentials done' });
+            return;
+        }
+        updateConfig(config) {
+            const { accessToken, refreshToken, expiration } = config;
+            this.config = Object.assign(Object.assign({}, this.config), { accessToken, refreshToken, expiration });
+            this.saveCredentials();
+        }
+        getSecret(key) {
+            var _a, _b;
+            return (_b = (_a = (0, api_1.getBindings)()) === null || _a === void 0 ? void 0 : _a.secret) === null || _b === void 0 ? void 0 : _b.getSecret(key);
+        }
+        getUserSettings() {
+            return (0, settings_1.useUserSettings)();
+        }
+        getApi() {
+            if (!this.api)
+                this.api = new strava_1.StravaApi();
+            return this.api;
+        }
+    };
+    __setFunctionName(_classThis, "StravaUpload");
+    (() => {
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        StravaUpload = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return StravaUpload = _classThis;
+})();
+exports.StravaUpload = StravaUpload;

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

@@ -1,3 +1,4 @@
+import { ActivityDetails } from "../base";
 export interface Credentials {
     username?: string;
     password?: string;
@@ -6,3 +7,19 @@ export interface VeloHeroAuth extends Credentials {
     id?: string;
     authKey?: string;
 }
+export type UploaderInfo = {
+    service: string;
+    uploader: IActivityUpload;
+};
+export type ActivityUploadResult = {
+    service: string;
+    success?: boolean;
+    error?: string;
+};
+export interface IActivityUpload {
+    init(): boolean;
+    isConnected(): boolean;
+    isConnecting(): boolean;
+    disconnect(): void;
+    upload(activity: ActivityDetails, format?: string): Promise<boolean>;
+}