signalk-to-noforeignland 0.1.22 → 0.1.25

package/CHANGELOG.md

@@ -0,0 +1,49 @@
+0.1.25
+* CHANGE: Minimum boat move default increased from 50m to 80m
+* CHANGE: Updated the README.md
+* CHANGE: Use public ipv4 DNS instead of local with cache for testInternet()
+* Final version after successful testing SV MOIN and SV KIAPA NUI
+
+0.1.25-beta.3
+* NEW: Check if boat key is set on startup, else report error to dashboard
+* CHANGE: Changing the order and label of the Plugin Settings to make it more clear for unexpierienced users and grouped to Mandatory, Advanced and Expert.
+* CHANGE: Migration of < 0.1.25 Plugin settings to new structure.
+* CHANGE: PluginStatus last track sent "Never" changed to "Not transfered since plugin start" to avoid confusions.
+
+
+0.1.25-beta.2
+* CHANGE: Typo in pluginName fixed
+* CHANGE: Dates for SetPlugin now ISO8601 formated (https://github.com/noforeignland/nfl-signalk/issues/9)
+
+0.1.25-beta.1
+* CHANGE: User mattzilla470 reported timout Issues on VE Cerbo with a small CPU and using 4G (https://github.com/noforeignland/nfl-signalk/issues/7). So added a timout option in the plugin config and a tripple retry while increasing the timeout for the API call.
+
+0.1.24
+* CHANGE: testInternet() only uses ipv4 now, some users don't have ipv6 configured properly and where unable to reach the API, when testInternet returned false
+* NEW: PluginStatus on SK dashboard now shows last savePoint and last API transfer, so a user has more feedback what the app is doing without enabling the debug log and crawling though it.
+* CHANGE: Renamed CHANGELOG to CHANGELOG.md
+* CHANGE: CHANGELOG ORDER - newest on top.
+* Final version after successful testing SV MOIN and  SV KIAPA NUI
+
+0.1.23
+* Final version after successful testing SV MOIN and SV KIAPA NUI
+
+0.1.23-beta.1
+* Renamed branch to follow the release versions. 
+* CLEANUP - More debug info for the SK dashboard using this.app.setPluginError
+* CLEANUP - Removed CreateGPX, was only used for removed Email transmission of the track
+
+0.1.22-beta.2
+
+* CLEANUP and move to Object Oriented Javascript
+
+0.1.22-beta.1
+
+* CONFIG: Attempt sending location while moving - Default changed from false to true
+* CONFIG: Ping added for 24h ping if boat is not moved. - Default: true
+* Package.json - Nodemailer dependency removed
+* Marked for removal - Depricated "sendEmailData" function.
+* REMOVED - sendEmail.js
+* CLEANUP - Renamed emaiCron to apiCron
+* NEW: 24h api ping, when enabled, even if boat didn't move.
+

package/README.md

@@ -5,13 +5,22 @@ Effortlessly log your boat's movement to **noforeignland.com**
 * Automatically log your position to NFL
 * Send detailed tracks to log your entire trip and not just your final position
 * Can be used in near real time or cache and upload when stopped and data-connection is available.
+* Can sent a 24h keepalive, when off the boat for a while.
 
-An internet connection is required in order to update NFL.
+## Issues
+* Report issues on GitHub (https://github.com/noforeignland/nfl-signalk/issues)
 
 ## Requirements
+* An internet connection is required in order to update NFL.
+* A navigation.position data path inside Signal K for self, which is your current GPS position
 * A **noforeignland.com** account
 * Your Boat API Key from the **noforeignland.com** website: 
   * Account > Settings > Boat tracking > API Key
 
 > Note your Boat API Key is not available in the app. 
-> You must sign in to the **noforeignland.com** website (using the same authentication method you use for the app: Google. Facebook, Email).
+> You must sign in to the **noforeignland.com** website (using the same authentication method you use for the app: Google. Facebook, Email).
+
+## Configuration
+1. Add your boat's API Key into the Server > Plugin Config > Signal K to Noforeignland > Boat API Key
+2. Hit "Submit"
+3. Restart the Signal K server 

package/index.js

@@ -1,4 +1,3 @@
-
 const { EOL } = require('os');
 const internetTestAddress = 'google.com';
 const internetTestTimeout = 1000;
@@ -8,480 +7,632 @@ const CronJob = require('cron').CronJob;
 const readline = require('readline');
 const fetch = require('node-fetch');
 const isReachable = require('is-reachable');
-const sendEmail = require('./sendEmail');
-const createGPX = require('./createGPX');
+
 const apiUrl = 'https://www.noforeignland.com/home/api/v1/boat/tracking/track';
 const pluginApiKey = '0ede6cb6-5213-45f5-8ab4-b4836b236f97';
-// const msToKn = 1.944;
-
-
-module.exports = function (app) {
-  var plugin = {};
-  plugin.id = 'signalk-to-noforeignland';
-  plugin.name = 'SignalK to Noforeignland';
-  plugin.description = 'SignalK track logger to noforeignland.com';
-
-  plugin.schema = {
-    "title": plugin.name,
-    "description": "Some parameters need for use",
-    "type": "object",
-    "required": ["emailCron", "boatApiKey"],
-    "properties": {
-      "trackFrequency": {
-        "type": "integer",
-        "title": "Position tracking frequency in seconds.",
-        "description": "To keep file sizes small we only log positions once in a while (unless you set this value to 0)",
-        "default": 60
-      },
-      "minMove": {
-        "type": "number",
-        "title": "Minimum boat move to log in meters",
-        "description": "To keep file sizes small we only log positions if a move larger than this size is noted (if set to 0 will log every move)",
-        "default": 50
-      },
-      "minSpeed": {
-        "type": "number",
-        "title": "Minimum boat speed to log in knots",
-        "description": "To keep file sizes small we only log positions if boat speed goes above this value to minimize recording position on anchor or mooring (if set to 0 will log every move)",
-        "default": 1.5
-      },
-      "emailCron": {
-        "type": "string",
-        "title": "Send attempt CRON",
-        "description": "We send the tracking data to NFL once in a while, you can set the schedule with this setting. CRON format: https://crontab.guru/",
-        "default": '*/10 * * * *',
-      },
-      'boatApiKey': {
-        "type": "string",
-        "title": "Boat API key",
-        "description": "Boat API key from noforeignland.com. Can be found in Account > Settings > Boat tracking > API Key. *required only in API method is set*",
-      },
-      "internetTestTimeout": {
-        "type": "number",
-        "title": "Timeout for testing internet connection in ms",
-        "description": "Set this number higher for slower computers and internet connections",
-        "default": 2000,
+const defaultTracksDir = 'track';
+const routeSaveName = 'nfl-track.jsonl';
+
+class SignalkToNoforeignland {
+  constructor(app) {
+    this.app = app;
+    this.pluginId = 'signalk-to-noforeignland';
+    this.pluginName = 'Signal K to Noforeignland';
+    this.creator = 'signalk-track-logger';
+
+    // runtime state
+    this.unsubscribes = [];
+    this.unsubscribesControl = [];
+    this.lastPosition = null;
+    this.upSince = null;
+    this.cron = null;
+    this.options = {};
+    this.lastSuccessfulTransfer = null;
+  }
+
+getSchema() {
+  return {
+    title: this.pluginName,
+    description: 'Some parameters need for use',
+    type: 'object',
+    required: ['boatApiKey', 'apiCron'],
+    properties: {
+      // Mandatory Settings Group
+      mandatory: {
+        type: 'object',
+        title: 'Mandatory Settings',
+        properties: {
+          boatApiKey: {
+            type: 'string',
+            title: 'Boat API Key',
+            description: 'Boat API Key from noforeignland.com. Can be found in Account > Settings > Boat tracking > API Key.'
+          }
+        }
       },
-      "sendWhileMoving": {
-        "type": "boolean",
-        "title": "Attempt sending location while moving",
-        "description": "Should the plugin attempt to send tracking data to NFL while detecting the vessel is moving or only when stopped?",
-        "default": false
+      
+      // Advanced Settings Group
+      advanced: {
+        type: 'object',
+        title: 'Advanced Settings',
+        properties: {
+          minMove: {
+            type: 'number',
+            title: 'Minimum boat move to log in meters',
+            description: 'To keep file sizes small we only log positions if a move larger than this size (if set to 0 will log every move)',
+            default: 80
+          },
+          minSpeed: {
+            type: 'number',
+            title: 'Minimum boat speed to log in knots',
+            description: 'To keep file sizes small we only log positions if boat speed goes above this value to minimize recording position on anchor or mooring (if set to 0 will log every move)',
+            default: 1.5
+          },
+          sendWhileMoving: {
+            type: 'boolean',
+            title: 'Attempt sending location while moving',
+            description: 'Should the plugin attempt to send tracking data to NFL while detecting the vessel is moving or only when stopped?',
+            default: true
+          },
+          ping_api_every_24h: {
+            type: 'boolean',
+            title: 'Force a send every 24 hours',
+            description: 'Keeps your boat active on NFL in your current location even if you do not move',
+            default: true
+          }
+        }
       },
-      "filterSource": {
-        "type": "string",
-        "title": "Position source device",
-        "description": "Set this value to the name of a source if you want to only use the position given by that source.",
+      
+      // Expert Settings Group
+      expert: {
+        type: 'object',
+        title: 'Expert Settings',
+        properties: {
+          filterSource: {
+            type: 'string',
+            title: 'Position source device',
+            description: 'EMPTY DEFAULT IS FINE - Set this value to the name of a source if you want to only use the position given by that source.'
+          },
+          trackDir: {
+            type: 'string',
+            title: 'Directory to cache tracks',
+            description: 'EMPTY DEFAULT IS FINE - Path in server filesystem, absolute or from plugin directory.\noptional param (only used to keep file cache).'
+          },
+          keepFiles: {
+            type: 'boolean',
+            title: 'Keep track files on disk',
+            description: 'If you have a lot of hard drive space you can keep the track files for logging purposes.',
+            default: false
+          },
+          trackFrequency: {
+            type: 'integer',
+            title: 'Position tracking frequency in seconds',
+            description: 'To keep file sizes small we only log positions once in a while (unless you set this value to 0)',
+            default: 60
+          },
+          apiCron: {
+            type: 'string',
+            title: 'Send attempt CRON',
+            description: 'We send the tracking data to NFL once in a while, you can set the schedule with this setting.\nCRON format: https://crontab.guru/',
+            default: '*/10 * * * *'
+          },
+          internetTestTimeout: {
+            type: 'number',
+            title: 'Timeout for testing internet connection in ms',
+            description: 'Set this number higher for slower computers and internet connections',
+            default: 2000
+          },
+          apiTimeout: {
+          type: 'integer',
+          title: 'API request timeout in seconds',
+          description: 'Timeout for sending data to NFL API. Increase for slow connections.',
+          default: 30,
+          minimum: 10,
+          maximum: 180
+        }
+        }
+      }
+    }
+  };
+}
+
+  getPluginObject() {
+    return {
+      id: this.pluginId,
+      name: this.pluginName,
+      description: 'SignalK track logger to noforeignland.com',
+      schema: this.getSchema(),
+      start: this.start.bind(this),
+      stop: this.stop.bind(this)
+    };
+  }
+
+  async start(options = {}, restartPlugin) {
+  
+  // Backward compatibility: migrate old flat structure to new nested structure
+  let needsSave = false;
+  if (options.boatApiKey && !options.mandatory) {
+    // Old config detected, migrate to new structure
+    this.app.debug('Migrating old configuration to new grouped structure');
+    needsSave = true;
+    
+    options = {
+      mandatory: {
+        boatApiKey: options.boatApiKey
       },
-      "trackDir": {
-        "type": "string",
-        "title": "Directory to cache tracks.",
-        "description": "Path in server filesystem, absolute or from plugin directory. optional param (only used to keep file cache).",
+      advanced: {
+        minMove: options.minMove !== undefined ? options.minMove : 50,
+        minSpeed: options.minSpeed !== undefined ? options.minSpeed : 1.5,
+        sendWhileMoving: options.sendWhileMoving !== undefined ? options.sendWhileMoving : true,
+        ping_api_every_24h: options.ping_api_every_24h !== undefined ? options.ping_api_every_24h : true
       },
-      "keepFiles": {
-        "type": "boolean",
-        "title": "Should keep track files on disk?",
-        "description": "If you have a lot of hard drive space you can keep the track files for logging purposes.",
-        "default": false
+      expert: {
+        filterSource: options.filterSource,
+        trackDir: options.trackDir,
+        keepFiles: options.keepFiles !== undefined ? options.keepFiles : false,
+        trackFrequency: options.trackFrequency !== undefined ? options.trackFrequency : 60,
+        internetTestTimeout: options.internetTestTimeout !== undefined ? options.internetTestTimeout : 2000,
+        apiCron: options.apiCron || '*/10 * * * *',
+        apiTimeout: options.apiTimeout !== undefined ? options.apiTimeout : 30
       }
+    };
+    
+    // Save the migrated configuration
+    try {
+      this.app.debug('Saving migrated configuration...');
+      await this.app.savePluginOptions(options, () => {
+        this.app.debug('Configuration successfully migrated and saved');
+      });
+    } catch (err) {
+      this.app.debug('Failed to save migrated configuration:', err.message);
+      // Continue anyway - the migration will work in memory
     }
+  }
+
+  // Flatten the nested structure for easier access and apply defaults
+  this.options = {
+    // Mandatory defaults
+    boatApiKey: options.mandatory?.boatApiKey,
+    
+    // Advanced defaults
+    minMove: options.advanced?.minMove !== undefined ? options.advanced.minMove : 80,
+    minSpeed: options.advanced?.minSpeed !== undefined ? options.advanced.minSpeed : 1.5,
+    sendWhileMoving: options.advanced?.sendWhileMoving !== undefined ? options.advanced.sendWhileMoving : true,
+    ping_api_every_24h: options.advanced?.ping_api_every_24h !== undefined ? options.advanced.ping_api_every_24h : true,
+    
+    // Expert defaults
+    filterSource: options.expert?.filterSource,
+    trackDir: options.expert?.trackDir || defaultTracksDir,
+    keepFiles: options.expert?.keepFiles !== undefined ? options.expert.keepFiles : false,
+    trackFrequency: options.expert?.trackFrequency !== undefined ? options.expert.trackFrequency : 60,
+    internetTestTimeout: options.expert?.internetTestTimeout !== undefined ? options.expert.internetTestTimeout : 2000,
+    apiCron: options.expert?.apiCron || '*/10 * * * *',
+    apiTimeout: options.expert?.apiTimeout !== undefined ? options.expert.apiTimeout : 30
   };
-
-  var unsubscribes = [];
-  var unsubscribesControl = [];
-  var routeSaveName = 'nfl-track.jsonl';
-  let lastPosition;
-  let upSince;
-  let cron;
-  const creator = 'signalk-track-logger';
-  const defaultTracksDir = 'track';
-  // const maxAllowedSpeed = 100;
-
-  plugin.start = function (options, restartPlugin) {
-    if (!options.trackDir) options.trackDir = defaultTracksDir;
-    if (!path.isAbsolute(options.trackDir)) options.trackDir = path.join(__dirname, options.trackDir);
-    //app.debug('options.trackDir=',options.trackDir);
-    if (!createDir(options.trackDir)) {
-      plugin.stop();
-      return;
+  
+  // Validate that boatApiKey is set
+  if (!this.options.boatApiKey || this.options.boatApiKey.trim() === '') {
+    const errorMsg = 'No boat API key configured. Please set your API key in plugin settings (Mandatory Settings > Boat API key). You can find your API key at noforeignland.com under Account > Settings > Boat tracking > API Key.';
+    this.app.debug(errorMsg);
+    this.app.setPluginError(errorMsg);
+    this.stop();
+    return;
+  }
+  
+  if (!path.isAbsolute(this.options.trackDir)) {
+    this.options.trackDir = path.join(__dirname, this.options.trackDir);
+  }
+
+  if (!this.createDir(this.options.trackDir)) {
+    this.stop();
+    return;
+  }
+
+  this.app.debug('track logger started, now logging to', this.options.trackDir);
+  this.app.setPluginStatus(`Started${needsSave ? ' (config migrated)' : ''}`);
+  this.upSince = new Date().getTime();
+
+  // adjust default CRON if unchanged
+  if (!this.options.apiCron || this.options.apiCron === '*/10 * * * *') {
+    const startMinute = Math.floor(Math.random() * 10);
+    const startSecond = Math.floor(Math.random() * 60);
+    this.options.apiCron = `${startSecond} ${startMinute}/10 * * * *`;
+  }
+
+  this.app.debug('Setting CRON to ', this.options.apiCron);
+  this.app.debug('trackFrequency is set to', this.options.trackFrequency, 'seconds');
+
+  // subscribe and logging
+  this.doLogging();
+
+  // start cron job
+  this.cron = new CronJob(this.options.apiCron, this.interval.bind(this));
+  this.cron.start();
+}
+
+  stop() {
+    this.app.debug('plugin stopped');
+    if (this.cron) {
+      this.cron.stop();
+      this.cron = undefined;
     }
-
-    app.debug('track logger started, now logging to', options.trackDir);
-    app.setPluginStatus(`Started`);
-
-    doLogging();
-
-    function doLogging() {
-      let shouldDoLog = true
-      //subscribe for position
-      app.subscriptionmanager.subscribe({
-        "context": "vessels.self",
-        "subscribe": [
-          {
-            "path": "navigation.position",
-            "format": "delta",
-            "policy": "instant",
-            "minPeriod": options.trackFrequency ? options.trackFrequency * 1000 : 0,
-          }
-        ]
-      },
-        unsubscribes,
-        subscriptionError => {
-          app.debug('Error subscription to data:' + subscriptionError);
-          app.setPluginError('Error subscription to data:' + subscriptionError.message);
-        },
-        doOnValue
-      );
-
-      //subscribe for speed
-      if (options.minSpeed) {
-        app.subscriptionmanager.subscribe({
-          "context": "vessels.self",
-          "subscribe": [
-            {
-              "path": "navigation.speedOverGround",
-              "format": "delta",
-              "policy": "instant",
-            }
-          ]
-        },
-          unsubscribes,
-          subscriptionError => {
-            app.debug('Error subscription to data:' + subscriptionError);
-            app.setPluginError('Error subscription to data:' + subscriptionError.message);
-          },
-          delta => {
-            // app.debug('got speed delta', delta);
-            delta.updates.forEach(update => {
-              // app.debug(`update:`, update);
-              if (options.filterSource && update.$source !== options.filterSource) {
-                return;
-              }
-              update.values.forEach(value => {
-                // value.value is sog in m/s so 'sog*2' is in knots
-                if (!shouldDoLog && options.minSpeed < value.value * 2) {
-                  app.debug('setting shouldDoLog to true');
-                  shouldDoLog = true;
-                }
-              })
-            })
-          }
-        );
-      }
-
-      async function doOnValue(delta) {
-
-        for (update of delta.updates) {
-          // app.debug(`update:`, update);
-          if (options.filterSource && update.$source !== options.filterSource) {
+    this.unsubscribesControl.forEach(f => f());
+    this.unsubscribesControl = [];
+    this.unsubscribes.forEach(f => f());
+    this.unsubscribes = [];
+    this.app.setPluginStatus('Plugin stopped');
+  }
+
+  doLogging() {
+    // subscribe for position
+    let shouldDoLog = true;
+
+    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);
+      this.app.setPluginError('Error subscription to data:' + subscriptionError.message);
+    }, this.doOnValue.bind(this, () => shouldDoLog, newShould => { shouldDoLog = newShould; }));
+
+    // subscribe for speed
+    if (this.options.minSpeed) {
+      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);
+        this.app.setPluginError('Error subscription to data:' + subscriptionError.message);
+      }, (delta) => {
+        delta.updates.forEach(update => {
+          if (this.options.filterSource && update.$source !== this.options.filterSource) {
             return;
           }
-          let timestamp = update.timestamp;
-          for (value of update.values) {
-			  
-		
-			if (
-			  Math.abs(value.value.latitude) <= 0.01 &&
-			  Math.abs(value.value.longitude) <= 0.01
-			) {
-			  // Coordinates are within ±0.1 of (0,0)
-			  return;
-			}
-			
-            // app.debug(`value:`, value);
-
-            if (!shouldDoLog) {
-              return;
+          update.values.forEach(value => {
+            const speedInKnots = value.value * 1.94384; 
+            if (!shouldDoLog && this.options.minSpeed < speedInKnots) { 
+              this.app.debug('setting shouldDoLog to true, speed:', speedInKnots.toFixed(2), 'knots'); 
+              shouldDoLog = true; 
             }
-            if (!isValidLatitude(value.value.latitude) || !isValidLongitude(value.value.longitude)) {
-              return;
-            }
-            
-            
-            if (lastPosition) {
-              if (new Date(lastPosition.timestamp).getTime() > new Date(timestamp).getTime()) {
-                app.debug('got error in timestamp:', timestamp, 'is earlier than previous:', lastPosition.timestamp);
-                // SK sometimes messes up timestamps, when that happens we throw the update
-                return;
-              }
-              const distance = equirectangularDistance(lastPosition.pos, value.value)
-              if (options.minMove && distance < options.minMove) {
-                return;
-              }
-              // if (calculatedSpeed(distance, (timestamp - lastPosition.timestamp) / 1000) > maxAllowedSpeed) {
-              //   app.debug('got error position', value.value, 'ignoring...');
-              //   return;
-              // }
-            }
-            lastPosition = { pos: value.value, timestamp, currentTime: new Date().getTime() };
-            
-            await savePoint(lastPosition);
-            if (options.minSpeed) {
-              app.debug('setting shouldDoLog to false');
-              shouldDoLog = false;
-            }
-          };
-        };
-      }
-    }
-
-    async function savePoint(point) {
-      //{pos: {latitude, longitude}, timestamp}
-      // Date.parse(timestamp)
-      const obj = {
-        lat: point.pos.latitude,
-        lon: point.pos.longitude,
-        t: point.timestamp,
-      }
-      app.debug(`save data point:`, obj);
-      await fs.appendFile(path.join(options.trackDir, routeSaveName), JSON.stringify(obj) + EOL);
-    }
-
-    function isValidLatitude(obj) {
-      return isDefinedNumber(obj) && obj > -90 && obj < 90
-    }
-
-    function isValidLongitude(obj) {
-      return isDefinedNumber(obj) && obj > -180 && obj < 180
-    }
-
-    function isDefinedNumber(obj) {
-      return (obj !== undefined && obj !== null && typeof obj === 'number');
+          });
+        });
+      });
     }
+  }
 
-    // function calculatedSpeed(distance, timeSecs) {
-    //   // m/s to knots ~= speedinms * 1.944
-    //   return (distance / timeSecs) * msToKn
-    // }
-
-    function equirectangularDistance(from, to) {
-      // https://www.movable-type.co.uk/scripts/latlong.html
-      // from,to: {longitude: xx, latitude: xx}
-      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;
+  async doOnValue(getShouldDoLog, setShouldDoLog, delta) {
+  for (const update of delta.updates) {
+    if (this.options.filterSource && update.$source !== this.options.filterSource) {
+      return;
     }
+    const timestamp = update.timestamp;
+    for (const value of update.values) {
+      // Validierung: GPS nahe (0,0)
+      if (Math.abs(value.value.latitude) <= 0.01 && Math.abs(value.value.longitude) <= 0.01) {
+        this.app.debug('GPS coordinates near (0,0), ignoring point to avoid invalid data logging.');
+        return;
+      }
+      
+      // Validate for valid lat/lon
+      if (!this.isValidLatitude(value.value.latitude) || !this.isValidLongitude(value.value.longitude)) {
+        this.app.debug('got invalid position, ignoring...', value.value);
+        return;
+      }
 
-    function createDir(dir) {
-      let res = true;
-      if (fs.existsSync(dir)) {
-        try {
-          fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK);
-        }
-        catch (error) {
-          app.debug('[createDir]', error.message);
-          app.setPluginError(`No rights to directory ${dir}`);
-          res = false;
+      // 24h-Ping Check: Setze Flag, aber breche NICHT ab
+      let force24hSave = false;
+      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');
+          force24hSave = true;
         }
       }
-      else {
-        try {
-          fs.mkdirSync(dir, { recursive: true });
+
+      // Wenn wir nicht loggen sollen UND es kein 24h-Force ist, dann raus
+      if (!force24hSave && !getShouldDoLog()) {
+        return;
+      }
+
+      // Wenn wir eine letzte Position haben, prüfe Timestamp und Distanz
+      if (this.lastPosition && !force24hSave) {
+        // Timestamp-Validierung
+        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;
         }
-        catch (error) {
-          switch (error.code) {
-            case 'EACCES':	// Permission denied
-            case 'EPERM':	// Operation not permitted
-              app.debug(`False to create ${dir} by Permission denied`);
-              app.setPluginError(`False to create ${dir} by Permission denied`);
-              res = false;
-              break;
-            case 'ETIMEDOUT':	// Operation timed out
-              app.debug(`False to create ${dir} by Operation timed out`);
-              app.setPluginError(`False to create ${dir} by Operation timed out`);
-              res = false;
-              break;
-          }
+        
+        // Distance-Check (nur wenn NICHT 24h-Force)
+        const distance = this.equirectangularDistance(this.lastPosition.pos, value.value);
+        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;
         }
       }
-      return res;
-    } // end function createDir
 
-    async function interval() {
-      if ((checkBoatMoving()) && await checkTrack() && await testInternet()) {
-        await sendData();
+      // Punkt speichern
+      this.lastPosition = { pos: value.value, timestamp, currentTime: new Date().getTime() };
+      await this.savePoint(this.lastPosition);
+
+      // shouldDoLog zurücksetzen wenn minSpeed aktiv ist
+      if (this.options.minSpeed) {
+        this.app.debug('options.minSpeed - setting shouldDoLog to false');
+        setShouldDoLog(false);
       }
     }
+  }}
 
-    function checkBoatMoving() {
-      if (options.sendWhileMoving || !options.trackFrequency) {
-        return true;
-      } 
-      const time = lastPosition ? lastPosition.currentTime : upSince;
-
-      const secsSinceLastPoint = (new Date().getTime() - time)/1000
-      if (secsSinceLastPoint > (options.trackFrequency * 2)) {
-        app.debug('Boat stopped moving, last move at least', secsSinceLastPoint,'seconds ago');
-        return true;
-      } else {
-        app.debug('Boat is still moving, last move', secsSinceLastPoint,'seconds ago');
-        return false;
+
+ 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.options.trackDir, routeSaveName), JSON.stringify(obj) + EOL);
+  
+  const lastSaveTime = new Date().toISOString();
+  const lastTransferTime = this.lastSuccessfulTransfer ? this.lastSuccessfulTransfer.toISOString() : 'Not transfered since plugin start';
+  this.app.setPluginStatus(`Last save: ${lastSaveTime} | Last transfer: ${lastTransferTime}`);
+  }
+
+  isValidLatitude(obj) {
+    return this.isDefinedNumber(obj) && obj > -90 && obj < 90;
+  }
+  isValidLongitude(obj) {
+    return this.isDefinedNumber(obj) && obj > -180 && obj < 180;
+  }
+  isDefinedNumber(obj) {
+    return (obj !== undefined && obj !== null && typeof obj === 'number');
+  }
+
+  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;
+  }
+
+  createDir(dir) {
+    let res = true;
+    if (fs.existsSync(dir)) {
+      try {
+        fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK);
+      } catch (error) {
+        this.app.debug('[createDir]', error.message);
+        this.app.setPluginError(`No rights to directory ${dir}`);
+        res = false;
+      }
+    } else {
+      try {
+        fs.mkdirSync(dir, { recursive: true });
+      } catch (error) {
+        switch (error.code) {
+          case 'EACCES':
+          case 'EPERM':
+            this.app.debug(`False to create ${dir} by Permission denied`);
+            this.app.setPluginError(`False to create ${dir} by Permission denied`);
+            res = false;
+            break;
+          case 'ETIMEDOUT':
+            this.app.debug(`False to create ${dir} by Operation timed out`);
+            this.app.setPluginError(`False to create ${dir} by Operation timed out`);
+            res = false;
+            break;
+          default:
+            this.app.debug(`Error creating directory ${dir}: ${error.message}`);
+            this.app.setPluginError(`Error creating directory ${dir}: ${error.message}`);
+            res = false;
+        }
       }
     }
+    return res;
+  }
 
-    async function testInternet() {
-      app.debug('testing internet connection');
-      const check = await isReachable(internetTestAddress, { timeout: options.internetTestTimeout || internetTestTimeout });
-      app.debug('internet connection = ', check);
-      return check;
+  // periodic interval called by cron
+  async interval() {
+    if ((this.checkBoatMoving()) && await this.checkTrack() && await this.testInternet()) {
+      await this.sendData();
     }
-
-    async function checkTrack() {
-      const trackFile = path.join(options.trackDir, routeSaveName);
-      app.debug('checking the track', trackFile, 'if should send');
-      const exists = await fs.pathExists(trackFile);
-      const size = exists ? (await fs.lstat(trackFile)).size : 0;
-      app.debug(`'${trackFile}'.size=${size} ${trackFile}'.exists=${exists}`);
-      return size > 0;
+  }
+
+  checkBoatMoving() { 
+    if (!this.options.trackFrequency) { 
+      return true; // Kein Tracking → immer senden 
+    } 
+    const time = this.lastPosition ? this.lastPosition.currentTime : this.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; // Nur senden wenn gewünscht 
+    } else { 
+      this.app.debug('Boat stopped moving, last move at least', secsSinceLastPoint, 'seconds ago'); 
+      return true; // Immer senden wenn gestoppt 
+      } 
+  }
+
+  async testInternet() {
+  const dns = require('dns').promises;
+  
+  this.app.debug('testing internet connection');
+  
+  const timeoutMs = this.options.internetTestTimeout || 2000;
+  
+  // Prüfe mehrere öffentliche DNS-Server
+  const dnsServers = [
+    { name: 'Google DNS', ip: '8.8.8.8' },
+    { name: 'Cloudflare DNS', ip: '1.1.1.1' }
+  ];
+  
+  for (const server of dnsServers) {
+    try {
+      // Versuche, den DNS-Server direkt zu erreichen
+      // Wir machen einen reverse lookup auf die IP selbst
+      const result = await Promise.race([
+        dns.reverse(server.ip),
+        new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('DNS timeout')), timeoutMs)
+        )
+      ]);
+      
+      this.app.debug(`internet connection = true, ${server.name} (${server.ip}) is reachable`);
+      return true;
+    } catch (err) {
+      this.app.debug(`${server.name} (${server.ip}) not reachable:`, err.message);
+      // Weiter zum nächsten Server
     }
-
-    async function sendData() {
-      if (options.boatApiKey) {
-        sendApiData();
-      } else {
-        sendEmailData();
-      }
+  }
+  
+  this.app.debug('internet connection = false, no public DNS servers reachable');
+  return false;
+}
+
+  async checkTrack() {
+    const trackFile = path.join(this.options.trackDir, 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;
+  }
+
+  async sendData() {
+    if (this.options.boatApiKey) {
+      await this.sendApiData();
+    } else {
+      this.app.debug('Failed to send track - no boat API key set in plugin settings.');
+      this.app.setPluginError(`Failed to send track - no boat API key set in plugin settings.`);
     }
-
-    async function sendApiData() {
-      app.debug('sending the data');
-      const trackData = await createTrack(path.join(options.trackDir, routeSaveName));
-      if (!trackData) {
-        app.debug('Recorded track did not contain any valid track points, aborting sending.');
-        return;
-      }
-      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', options.boatApiKey);
-
-      const headers = {
-        'X-NFL-API-Key': pluginApiKey
-      }
-
-      app.debug('sending track to API');
+  }
+
+  async sendApiData() {
+    this.app.debug('sending the data');
+    const trackData = await this.createTrack(path.join(this.options.trackDir, routeSaveName));
+    if (!trackData) {
+      this.app.debug('Recorded track did not contain any valid track points, aborting sending.');
+      this.app.setPluginError(`Failed to send track - Recorded track did not contain any valid track points, aborting sending.`);
+      return;
+    }
+    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': pluginApiKey };
+    this.app.debug('sending track to API');
+
+    // Retry-Logik mit exponentiell steigendem Timeout
+    const maxRetries = 3;
+    const baseTimeout = (this.options.apiTimeout || 30) * 1000; // Konfigurierbarer Basis-Timeout in ms
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
       try {
-        const response = await fetch(apiUrl, { method: 'POST', body: params, headers: new fetch.Headers(headers) });
+        const currentTimeout = baseTimeout * attempt; // 30s, 60s, 90s
+        this.app.debug(`Attempt ${attempt}/${maxRetries} with ${currentTimeout}ms timeout`);
+        
+        // AbortController für Timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), currentTimeout);
+        
+        const response = await fetch(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') {
-            app.debug('Track successfully sent to API');
-            if (options.keepFiles) {
+            this.lastSuccessfulTransfer = new Date();
+            this.app.debug('Track successfully sent to API');
+            this.app.setPluginStatus(`Started - last Track sent successfully at ${new Date().toISOString()}`);
+            if (this.options.keepFiles) {
               const filename = new Date().toJSON().slice(0, 19).replace(/:/g, '') + '-nfl-track.jsonl';
-              app.debug('moving and keeping track file: ', filename);
-              await fs.move(path.join(options.trackDir, routeSaveName), path.join(options.trackDir, filename));
+              this.app.debug('moving and keeping track file: ', filename);
+              await fs.move(path.join(this.options.trackDir, routeSaveName), path.join(this.options.trackDir, filename));
             } else {
-              app.debug('Deleting track file');
-              await fs.remove(path.join(options.trackDir, routeSaveName));
+              this.app.debug('Deleting track file');
+              await fs.remove(path.join(this.options.trackDir, routeSaveName));
             }
+            return; // Erfolg - beende Funktion
           } else {
-            app.debug('Could not send track to API, returned response json:', responseBody);
+            this.app.debug('Could not send track to API, returned response json:', responseBody);
+            // Bei API-Fehler nicht erneut versuchen
+            this.app.setPluginError(`Failed to send track - API returned error.`);
+            return;
           }
         } else {
-          app.debug('Could not send track to API, returned response code:', response.status, response.statusText);
+          this.app.debug('Could not send track to API, returned response code:', response.status, response.statusText);
+          // Bei 4xx Fehler nicht erneut versuchen
+          if (response.status >= 400 && response.status < 500) {
+            this.app.setPluginError(`Failed to send track - HTTP ${response.status}.`);
+            return;
+          }
+          // Bei 5xx Fehler retry
+          throw new Error(`HTTP ${response.status}`);
         }
       } catch (err) {
-        app.debug('Could not send track to API due to error:', err);
-      }
-    }
-
-    async function createTrack(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) && isValidLatitude(point.lat) && isValidLongitude(point.lon)) {
-			  track.push([timestamp, point.lat, point.lon]);
-			  lastTimestamp = timestamp;
-			}
-			
-          } catch (error) {
-            app.debug('could not parse line from track file:', line);
-          }
+        this.app.debug(`Attempt ${attempt} failed:`, err.message);
+        
+        // Bei letztem Versuch Fehler setzen
+        if (attempt === maxRetries) {
+          this.app.debug('Could not send track to API after', maxRetries, 'attempts:', err);
+          this.app.setPluginError(`Failed to send track after ${maxRetries} attempts - check logs for details.`);
+        } else {
+          // Kurze Pause vor nächstem Versuch
+          const waitTime = 2000 * attempt; // 2s, 4s
+          this.app.debug(`Waiting ${waitTime}ms before retry...`);
+          await new Promise(resolve => setTimeout(resolve, waitTime));
         }
       }
-      if (track.length > 0) {
-        return { timestamp: new Date(lastTimestamp).getTime(), track };
-      }
     }
-
-    async function sendEmailData() {
-      app.debug('sending the data');
-      const gpxFiles = await createGPX({ input: path.join(options.trackDir, routeSaveName), outputDir: options.trackDir, creator });
-      app.debug('created GPX files', gpxFiles);
-      try {
-        for (let file of gpxFiles) {
-          app.debug('sending', file);
-          try {
-            !await sendEmail({
-              emailService: options.emailService,
-              user: options.emailUser,
-              password: options.emailPassword,
-              from: options.emailFrom,
-              to: options.emailTo,
-              trackFile: file
-            })
-          } catch (err) {
-            app.debug('Sending email failed:', err);
-            return;
+  }
+  async createTrack(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;
           }
-        }
-      } finally {
-        for (let file of gpxFiles) {
-          app.debug('deleting', file);
-          await fs.rm(file);
+        } catch (error) {
+          this.app.debug('could not parse line from track file:', line);
+          this.app.setPluginError(`Failed could not parse line from track file - check logs for details.`);
         }
       }
-      await fs.rm(path.join(options.trackDir, routeSaveName));
     }
-	//every 10 minute but staggered to the second so we don't all send at once.
-	if (!options.emailCron || options.emailCron === '*/10 * * * *') {
-	   const startMinute = Math.floor(Math.random() * 10);  // Random minute within the 10-minute range
-	   const startSecond = Math.floor(Math.random() * 60);  // Random second within the minute
-	   options.emailCron = `${startSecond} ${startMinute}/10 * * * *`;  // Every 10 minutes, starting at a random minute and second within each 10-minute block
-	 }
-
-    upSince = new Date().getTime();
-
-    app.debug('Setting CRON to ', options.emailCron);
-    cron = new CronJob(
-      options.emailCron,
-      interval
-    );
-    cron.start();
-  }; 	// end plugin.start
-
-  plugin.stop = function () {
-    app.debug('plugin stopped');
-    if (cron) {
-      cron.stop();
-      cron = undefined;
+    if (track.length > 0) {
+      return { timestamp: new Date(lastTimestamp).getTime(), track };
     }
-    unsubscribesControl.forEach(f => f());
-    unsubscribesControl = [];
-    unsubscribes.forEach(f => f());
-    unsubscribes = [];
-    app.setPluginStatus('Plugin stopped');
-  }; // end plugin.stop
-
+    return null;
+  }
+}
 
-  return plugin;
+module.exports = function (app) {
+  const instance = new SignalkToNoforeignland(app);
+  return instance.getPluginObject();
 };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "signalk-to-noforeignland",
-  "version": "0.1.22",
+  "version": "0.1.25",
   "description": "SignalK track logger to noforeignland.com ",
   "main": "index.js",
   "keywords": [
     "signalk-node-server-plugin",
     "signalk-category-utility"
   ],
-  "author": "Ian Miller",
+  "author": "Dirk Wahrheit",
   "homepage": "https://github.com/noforeignland/nfl-signalk",
   "bugs": {
     "url": "https://github.com/noforeignland/nfl-signalk/issues"
@@ -23,7 +23,6 @@
     "cron": "^2.1.0",
     "fs-extra": "^10.1.0",
     "is-reachable": "^5.2.1",
-    "node-fetch": "^2.6.7",
-    "nodemailer": "^6.8.0"
+    "node-fetch": "^2.6.7"
   }
 }

package/createGPX.js

@@ -1,48 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const readline = require('readline');
-
-async function createGPX(options) {
-    await writeHeader(options);
-    const fileStream = fs.createReadStream(options.input);
-
-    const rl = readline.createInterface({
-        input: fileStream,
-        crlfDelay: Infinity
-    });
-
-    for await (const line of rl) {
-      if (line){        
-        const point = JSON.parse(line);
-        let trkpt = '			<trkpt ';
-        trkpt += `lat="${point.lat}" lon="${point.lon}">\n`;
-        trkpt += `				<time>${point.t}</time>\n`;
-        trkpt += '			</trkpt>\n';
-        fs.appendFileSync(path.join(options.outputDir, 'track.gpx'), trkpt);
-      }
-    }
-    await writeFooter(options);
-    return [path.join(options.outputDir, 'track.gpx')];
-}
-
-async function writeHeader(options) {
-  const header = `<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-  <gpx version="1.1" creator="${options.creator}"
-          xmlns="http://www.topografix.com/GPX/1/1"  
-          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
-          xmlns:gpxx="http://www8.garmin.com/xmlschemas/GpxExtensions/v3"
-          xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd https://www8.garmin.com/xmlschemas/GpxExtensions/v3 https://www8.garmin.com/xmlschemas/GpxExtensions/v3/GpxExtensionsv3.xsd"
-  >
-      <metadata/>
-      <trk>
-          <trkseg>
-  `;
-  fs.writeFileSync(path.join(options.outputDir, 'track.gpx'), header);
-}
-
-async function writeFooter(options) {
-  const footer = '		</trkseg>\n	</trk>\n</gpx>';
-  fs.appendFileSync(path.join(options.outputDir, 'track.gpx'), footer);
-}
-
-module.exports = createGPX;

package/sendEmail.js

@@ -1,24 +0,0 @@
-const nodemailer = require('nodemailer');
-
-async function sendEmail(options) {
-    const mail = nodemailer.createTransport({
-        service: options.emailService,
-        auth: {
-            user: options.user,
-            pass: options.password,
-        }
-    });
-    var mailOptions = {
-        from: options.from,
-        to: options.to,
-        subject: `GPX ${(new Date()).toISOString()}`,
-        text: 'Generated by SignalK Tracker',
-        attachments: [{   // file on disk as an attachment
-            filename: 'track.gpx',
-            path: options.trackFile // stream this file
-        }],
-    };
-    await mail.sendMail(mailOptions);
-}
-
-module.exports = sendEmail;