@noforeignland/signalk-to-noforeignland 1.0.1-beta.8 → 1.1.0-beta.11

package/lib/TrackLogger.js

@@ -0,0 +1,306 @@
+const { EOL } = require('os');
+const fs = require('fs-extra');
+const path = require('path');
+
+class TrackLogger {
+  constructor(app, options, trackDir) {
+    this.app = app;
+    this.options = options;
+    this.trackDir = trackDir;
+    this.routeSaveName = 'pending.jsonl';
+    
+    this.lastPosition = null;
+    this.lastPositionReceived = null;
+    this.autoSelectedSource = null;
+    this.unsubscribes = [];
+  }
+
+  /**
+   * Start logging position data
+   */
+  startLogging(onSavePoint) {
+    let shouldDoLog = true;
+
+    // Subscribe to position updates
+    this.app.subscriptionmanager.subscribe({
+      context: 'vessels.self',
+      subscribe: [{
+        path: 'navigation.position',
+        format: 'delta',
+        policy: 'instant',
+        minPeriod: this.options.trackFrequency ? this.options.trackFrequency * 1000 : 0
+      }]
+    }, this.unsubscribes, 
+    (subscriptionError) => {
+      this.app.debug('Error subscription to data:' + subscriptionError);
+      throw new Error('Error subscription to data:' + subscriptionError.message);
+    }, 
+    this.doOnValue.bind(this, () => shouldDoLog, newShould => { shouldDoLog = newShould; }, onSavePoint));
+
+    // Subscribe for speed if minSpeed is configured
+    if (this.options.minSpeed) {
+      this.subscribeToSpeed(() => shouldDoLog, newShould => { shouldDoLog = newShould; });
+    }
+  }
+
+  /**
+   * Subscribe to speed over ground
+   */
+  subscribeToSpeed(getShouldDoLog, setShouldDoLog) {
+    this.app.subscriptionmanager.subscribe({
+      context: 'vessels.self',
+      subscribe: [{
+        path: 'navigation.speedOverGround',
+        format: 'delta',
+        policy: 'instant'
+      }]
+    }, this.unsubscribes, 
+    (subscriptionError) => {
+      this.app.debug('Error subscription to data:' + subscriptionError);
+      throw new Error('Error subscription to data:' + subscriptionError.message);
+    }, 
+    (delta) => {
+      delta.updates.forEach(update => {
+        if (this.options.filterSource && update.$source !== this.options.filterSource) {
+          return;
+        }
+        update.values.forEach(value => {
+          const speedInKnots = value.value * 1.94384; 
+          if (!getShouldDoLog() && this.options.minSpeed < speedInKnots) { 
+            this.app.debug('setting shouldDoLog to true, speed:', speedInKnots.toFixed(2), 'knots'); 
+            setShouldDoLog(true); 
+          }
+        });
+      });
+    });
+  }
+
+  /**
+   * Handle incoming position values
+   */
+  async doOnValue(getShouldDoLog, setShouldDoLog, onSavePoint, delta) {
+    for (const update of delta.updates) {
+      // Handle source selection (auto or filtered)
+      if (!this.handleSourceSelection(update)) {
+        continue;
+      }
+      
+      const timestamp = update.timestamp;
+      
+      for (const value of update.values) {
+        // Validate position
+        if (!this.isValidPosition(value.value)) {
+          continue;
+        }
+
+        // Check if we should save (24h ping or shouldDoLog)
+        const force24hSave = this.should24hPing();
+        if (!force24hSave && !getShouldDoLog()) {
+          this.app.debug('shouldDoLog is false, not logging position');
+          continue;
+        }
+
+        // Check timestamp and distance
+        if (this.lastPosition && !force24hSave) {
+          if (!this.shouldLogPosition(timestamp, value.value)) {
+            continue;
+          }
+        }
+
+        // Save point
+        this.app.debug('Saving position from source:', update.$source, 
+          'lat:', value.value.latitude, 'lon:', value.value.longitude);
+        
+        this.lastPosition = { 
+          pos: value.value, 
+          timestamp, 
+          currentTime: new Date().getTime() 
+        };
+        
+        await this.savePoint(this.lastPosition);
+        onSavePoint(this.lastPosition);
+
+        // Reset shouldDoLog if minSpeed is active
+        if (this.options.minSpeed) {
+          this.app.debug('options.minSpeed - setting shouldDoLog to false');
+          setShouldDoLog(false);
+        }
+      }
+    }
+  }
+
+  /**
+   * Handle GNSS source selection (auto-select or filtered)
+   */
+  handleSourceSelection(update) {
+    if (!this.options.filterSource) {
+      // Auto-select logic
+      const timeSinceLastPosition = this.lastPositionReceived 
+        ? (new Date().getTime() - this.lastPositionReceived) / 1000 
+        : null;
+      
+      if (!this.autoSelectedSource) {
+        this.autoSelectedSource = update.$source;
+        this.lastPositionReceived = new Date().getTime();
+        this.app.debug(`Auto-selected GNSS source: '${this.autoSelectedSource}'`);
+      } else if (update.$source !== this.autoSelectedSource) {
+        if (timeSinceLastPosition && timeSinceLastPosition > 300) {
+          this.app.debug(`Switching from stale source '${this.autoSelectedSource}' to '${update.$source}' (no data for ${timeSinceLastPosition.toFixed(0)}s)`);
+          this.autoSelectedSource = update.$source;
+          this.lastPositionReceived = new Date().getTime();
+        } else {
+          this.app.debug(`Ignoring position from '${update.$source}', using auto-selected source '${this.autoSelectedSource}'`);
+          return false;
+        }
+      } else {
+        this.lastPositionReceived = new Date().getTime();
+      }
+    } else if (update.$source !== this.options.filterSource) {
+      // Filtered source
+      this.app.debug(`Ignoring position from '${update.$source}', filterSource is set to '${this.options.filterSource}'`);
+      return false;
+    } else {
+      this.lastPositionReceived = new Date().getTime();
+    }
+    
+    return true;
+  }
+
+  /**
+   * Validate position (lat/lon and not at 0,0)
+   */
+  isValidPosition(position) {
+    // Check if near (0,0) - likely invalid
+    if (Math.abs(position.latitude) <= 0.01 && Math.abs(position.longitude) <= 0.01) {
+      this.app.debug('GNSS coordinates near (0,0), ignoring point to avoid invalid data logging.');
+      return false;
+    }
+    
+    // Validate lat/lon ranges
+    if (!this.isValidLatitude(position.latitude) || !this.isValidLongitude(position.longitude)) {
+      this.app.debug('got invalid position, ignoring...', position);
+      return false;
+    }
+    
+    return true;
+  }
+
+  /**
+   * Check if 24h ping should force a save
+   */
+  should24hPing() {
+    if (this.options.ping_api_every_24h && this.lastPosition) {
+      const timeSinceLastPoint = (new Date().getTime() - this.lastPosition.currentTime);
+      if (timeSinceLastPoint >= 24 * 60 * 60 * 1000) {
+        this.app.debug('24h since last point, forcing save of point to keep boat active on NFL');
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check if position should be logged based on timestamp and distance
+   */
+  shouldLogPosition(timestamp, position) {
+    // Check timestamp
+    if (new Date(this.lastPosition.timestamp).getTime() > new Date(timestamp).getTime()) {
+      this.app.debug('got error in timestamp:', timestamp, 'is earlier than previous:', this.lastPosition.timestamp);
+      return false;
+    }
+    
+    // Check distance
+    const distance = this.equirectangularDistance(this.lastPosition.pos, position);
+    if (this.options.minMove && distance < this.options.minMove) {
+      this.app.debug('Distance', distance.toFixed(2), 'm is less than minMove', this.options.minMove, 'm - skipping');
+      return false;
+    }
+    
+    this.app.debug('Distance', distance.toFixed(2), 'm is greater than minMove', this.options.minMove, 'm - logging');
+    return true;
+  }
+
+  /**
+   * Save position point to file
+   */
+  async savePoint(point) {
+    const obj = {
+      lat: point.pos.latitude,
+      lon: point.pos.longitude,
+      t: point.timestamp
+    };
+    this.app.debug(`save data point:`, obj);
+    await fs.appendFile(
+      path.join(this.trackDir, this.routeSaveName), 
+      JSON.stringify(obj) + EOL
+    );
+  }
+
+  /**
+   * Calculate distance between two positions
+   */
+  equirectangularDistance(from, to) {
+    const rad = Math.PI / 180;
+    const φ1 = from.latitude * rad;
+    const φ2 = to.latitude * rad;
+    const Δλ = (to.longitude - from.longitude) * rad;
+    const R = 6371e3;
+    const x = Δλ * Math.cos((φ1 + φ2) / 2);
+    const y = (φ2 - φ1);
+    const d = Math.sqrt(x * x + y * y) * R;
+    return d;
+  }
+
+  /**
+   * Validate latitude
+   */
+  isValidLatitude(obj) {
+    return this.isDefinedNumber(obj) && obj > -90 && obj < 90;
+  }
+  
+  /**
+   * Validate longitude
+   */
+  isValidLongitude(obj) {
+    return this.isDefinedNumber(obj) && obj > -180 && obj < 180;
+  }
+  
+  /**
+   * Check if value is a defined number
+   */
+  isDefinedNumber(obj) {
+    return (obj !== undefined && obj !== null && typeof obj === 'number');
+  }
+
+  /**
+   * Stop logging and unsubscribe
+   */
+  stop() {
+    this.unsubscribes.forEach(f => f());
+    this.unsubscribes = [];
+    this.autoSelectedSource = null;
+  }
+
+  /**
+   * Get last position
+   */
+  getLastPosition() {
+    return this.lastPosition;
+  }
+
+  /**
+   * Get last position received time
+   */
+  getLastPositionReceived() {
+    return this.lastPositionReceived;
+  }
+
+  /**
+   * Get auto-selected source
+   */
+  getAutoSelectedSource() {
+    return this.autoSelectedSource;
+  }
+}
+
+module.exports = TrackLogger;

package/lib/TrackMigration.js

@@ -0,0 +1,110 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class TrackMigration {
+  constructor(app, trackDir) {
+    this.app = app;
+    this.trackDir = trackDir;
+    this.routeSaveName = 'pending.jsonl';
+    this.routeSentName = 'sent.jsonl';
+  }
+
+  /**
+   * Migrate old track file names to new naming scheme
+   */
+  async migrate() {
+    const oldTrackFile = path.join(this.trackDir, 'nfl-track.jsonl');
+    const oldPendingFile = path.join(this.trackDir, 'nfl-track-pending.jsonl');
+    const oldSentFile = path.join(this.trackDir, 'nfl-track-sent.jsonl');
+    const newPendingFile = path.join(this.trackDir, this.routeSaveName);
+    const newSentFile = path.join(this.trackDir, this.routeSentName);
+    
+    try {
+      // Migrate old track file
+      await this.migrateSingleFile(oldTrackFile, newPendingFile, 'track file');
+      
+      // Migrate old pending file
+      await this.migrateSingleFile(oldPendingFile, newPendingFile, 'pending file');
+      
+      // Migrate old sent file
+      await this.migrateSingleFile(oldSentFile, newSentFile, 'sent file');
+      
+      // Check old plugin directory location
+      await this.migrateFromOldPluginDir(newPendingFile, newSentFile);
+      
+    } catch (err) {
+      this.app.debug('Error during track file migration:', err.message);
+    }
+  }
+
+  /**
+   * Migrate a single file if it exists
+   */
+  async migrateSingleFile(oldPath, newPath, description) {
+    if (await fs.pathExists(oldPath) && !(await fs.pathExists(newPath))) {
+      this.app.debug(`Migrating old ${description} to new naming scheme...`);
+      await fs.move(oldPath, newPath);
+      this.app.debug(`Successfully migrated old ${description} to: ${path.basename(newPath)}`);
+    }
+  }
+
+  /**
+   * Migrate track files from old plugin directory location
+   */
+  async migrateFromOldPluginDir(newPendingFile, newSentFile) {
+    const oldPluginTrackDir = path.join(__dirname, '..', 'track');
+    
+    if (!(await fs.pathExists(oldPluginTrackDir))) {
+      return;
+    }
+    
+    this.app.debug('Found old track directory in plugin folder, migrating to new location...');
+    
+    // Migrate pending files
+    const oldPendingFiles = [
+      'nfl-track.jsonl',
+      'nfl-track-pending.jsonl',
+      this.routeSaveName
+    ];
+    
+    for (const oldFile of oldPendingFiles) {
+      const oldPath = path.join(oldPluginTrackDir, oldFile);
+      if (await fs.pathExists(oldPath) && !(await fs.pathExists(newPendingFile))) {
+        await fs.move(oldPath, newPendingFile);
+        this.app.debug('Migrated pending track file from old plugin location');
+        break;
+      }
+    }
+    
+    // Migrate sent archive
+    const oldSentFiles = [this.routeSentName, 'nfl-track-sent.jsonl'];
+    for (const oldFile of oldSentFiles) {
+      const oldPath = path.join(oldPluginTrackDir, oldFile);
+      if (await fs.pathExists(oldPath) && !(await fs.pathExists(newSentFile))) {
+        await fs.move(oldPath, newSentFile);
+        this.app.debug('Migrated sent track archive from old plugin location');
+        break;
+      }
+    }
+    
+    // Try to remove old directory if empty
+    await this.removeOldDirectoryIfEmpty(oldPluginTrackDir);
+  }
+
+  /**
+   * Remove old directory if it's empty
+   */
+  async removeOldDirectoryIfEmpty(dirPath) {
+    try {
+      const remainingFiles = await fs.readdir(dirPath);
+      if (remainingFiles.length === 0) {
+        await fs.rmdir(dirPath);
+        this.app.debug('Removed empty old track directory');
+      }
+    } catch (err) {
+      this.app.debug('Could not remove old track directory:', err.message);
+    }
+  }
+}
+
+module.exports = TrackMigration;

package/lib/TrackSender.js

@@ -0,0 +1,219 @@
+const fs = require('fs-extra');
+const path = require('path');
+const readline = require('readline');
+const fetch = require('node-fetch');
+
+class TrackSender {
+  constructor(app, options, trackDir) {
+    this.app = app;
+    this.options = options;
+    this.trackDir = trackDir;
+    this.routeSaveName = 'pending.jsonl';
+    this.routeSentName = 'sent.jsonl';
+    
+    this.apiUrl = 'https://www.noforeignland.com/home/api/v1/boat/tracking/track';
+    this.pluginApiKey = '0ede6cb6-5213-45f5-8ab4-b4836b236f97';
+  }
+
+  /**
+   * Check if boat is currently moving
+   */
+  isBoatMoving(lastPosition, upSince) {
+    if (!this.options.trackFrequency) { 
+      return true;
+    } 
+    
+    const time = lastPosition ? lastPosition.currentTime : upSince; 
+    const secsSinceLastPoint = (new Date().getTime() - time) / 1000; 
+    const isMoving = secsSinceLastPoint <= (this.options.trackFrequency * 2); 
+    
+    if (isMoving) { 
+      this.app.debug('Boat is still moving, last move', secsSinceLastPoint, 'seconds ago'); 
+      return this.options.sendWhileMoving;
+    } else { 
+      this.app.debug('Boat stopped moving, last move at least', secsSinceLastPoint, 'seconds ago'); 
+      return true;
+    } 
+  }
+
+  /**
+   * Check if track file exists and has content
+   */
+  async hasTrackData() {
+    const trackFile = path.join(this.trackDir, this.routeSaveName);
+    this.app.debug('checking the track', trackFile, 'if should send');
+    
+    const exists = await fs.pathExists(trackFile);
+    const size = exists ? (await fs.lstat(trackFile)).size : 0;
+    
+    this.app.debug(`'${trackFile}'.size=${size} ${trackFile}'.exists=${exists}`);
+    return size > 0;
+  }
+
+  /**
+   * Send track data to API
+   */
+  async sendTrack() {
+    if (!this.options.boatApiKey) {
+      throw new Error('No boat API key set in plugin settings.');
+    }
+
+    this.app.debug('sending the data');
+    const pendingFile = path.join(this.trackDir, this.routeSaveName);
+    const trackData = await this.createTrackFromFile(pendingFile);
+    
+    if (!trackData) {
+      throw new Error('Recorded track did not contain any valid track points, aborting sending.');
+    }
+    
+    this.app.debug('created track data with timestamp:', new Date(trackData.timestamp));
+    
+    const params = new URLSearchParams();
+    params.append('timestamp', trackData.timestamp);
+    params.append('track', JSON.stringify(trackData.track));
+    params.append('boatApiKey', this.options.boatApiKey);
+    
+    const headers = { 'X-NFL-API-Key': this.pluginApiKey };
+    this.app.debug('sending track to API');
+
+    const success = await this.sendWithRetry(params, headers);
+    
+    if (success) {
+      await this.handleSuccessfulSend(pendingFile);
+    }
+    
+    return success;
+  }
+
+  /**
+   * Send data with retry logic
+   */
+  async sendWithRetry(params, headers) {
+    const maxRetries = 3;
+    const baseTimeout = (this.options.apiTimeout || 30) * 1000;
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const currentTimeout = baseTimeout * attempt;
+        this.app.debug(`Attempt ${attempt}/${maxRetries} with ${currentTimeout}ms timeout`);
+        
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), currentTimeout);
+        
+        const response = await fetch(this.apiUrl, { 
+          method: 'POST', 
+          body: params, 
+          headers: new fetch.Headers(headers),
+          signal: controller.signal
+        });
+        
+        clearTimeout(timeoutId);
+        
+        if (response.ok) {
+          const responseBody = await response.json();
+          if (responseBody.status === 'ok') {
+            this.app.debug('Track successfully sent to API');
+            return true;
+          } else {
+            this.app.debug('Could not send track to API, returned response json:', responseBody);
+            throw new Error('API returned error.');
+          }
+        } else {
+          this.app.debug('Could not send track to API, returned response code:', response.status, response.statusText);
+          if (response.status >= 400 && response.status < 500) {
+            throw new Error(`HTTP ${response.status}.`);
+          }
+          throw new Error(`HTTP ${response.status}`);
+        }
+      } catch (err) {
+        this.app.debug(`Attempt ${attempt} failed:`, err.message);
+        
+        if (attempt === maxRetries) {
+          this.app.debug('Could not send track to API after', maxRetries, 'attempts:', err);
+          throw new Error(`Failed to send track after ${maxRetries} attempts - check logs for details.`);
+        } else {
+          const waitTime = 2000 * attempt;
+          this.app.debug(`Waiting ${waitTime}ms before retry...`);
+          await new Promise(resolve => setTimeout(resolve, waitTime));
+        }
+      }
+    }
+    
+    return false;
+  }
+
+  /**
+   * Handle successful send (archive or delete track file)
+   */
+  async handleSuccessfulSend(pendingFile) {
+    const sentFile = path.join(this.trackDir, this.routeSentName);
+    
+    try {
+      if (this.options.keepFiles) {
+        this.app.debug('Appending sent data to archive file:', this.routeSentName);
+        const pendingContent = await fs.readFile(pendingFile, 'utf8');
+        await fs.appendFile(sentFile, pendingContent);
+        this.app.debug('Successfully archived sent track data');
+      } else {
+        this.app.debug('keepFiles disabled, will delete pending file');
+      }
+      
+      this.app.debug('Deleting pending track file');
+      await fs.remove(pendingFile);
+      this.app.debug('Successfully processed track files after send');
+      
+    } catch (err) {
+      this.app.debug('Error handling files after successful send:', err.message);
+    }
+  }
+
+  /**
+   * Create track data from file
+   */
+  async createTrackFromFile(inputPath) {
+    const fileStream = fs.createReadStream(inputPath);
+    const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+    const track = [];
+    let lastTimestamp;
+    
+    for await (const line of rl) {
+      if (line) {
+        try {
+          const point = JSON.parse(line);
+          const timestamp = new Date(point.t).getTime();
+          
+          if (!isNaN(timestamp) && 
+              this.isValidLatitude(point.lat) && 
+              this.isValidLongitude(point.lon)) {
+            track.push([timestamp, point.lat, point.lon]);
+            lastTimestamp = timestamp;
+          }
+        } catch (error) {
+          this.app.debug('could not parse line from track file:', line);
+        }
+      }
+    }
+    
+    if (track.length > 0) {
+      return { timestamp: new Date(lastTimestamp).getTime(), track };
+    }
+    
+    return null;
+  }
+
+  /**
+   * Validate latitude
+   */
+  isValidLatitude(obj) {
+    return (obj !== undefined && obj !== null && typeof obj === 'number' && obj > -90 && obj < 90);
+  }
+  
+  /**
+   * Validate longitude
+   */
+  isValidLongitude(obj) {
+    return (obj !== undefined && obj !== null && typeof obj === 'number' && obj > -180 && obj < 180);
+  }
+}
+
+module.exports = TrackSender;

package/package.json

@@ -3,7 +3,7 @@
   "signalk": {
     "id": "@noforeignland/signalk-to-noforeignland"
   },
-  "version": "1.0.1-beta.8",
+  "version": "1.1.0-beta.11",
   "description": "SignalK track logger to noforeignland.com",
   "main": "index.js",
   "keywords": [

package/doc/dev

@@ -1,17 +0,0 @@
-
-INTERNAL NOTES ONLY, IGNORE.
-
-
-cd ~/dirk/nfl-signalk
-
-# Aktuelle Version zu Beta machen
-npm version 1.0.1-beta.1 --no-git-tag-version
-
-# Package bauen
-npm pack
-
-# Mit beta tag publishen (nicht als 'latest')
-npm publish --tag beta
-
-# Falls du noch nicht eingeloggt bist:
-npm login