signalk-to-noforeignland 0.1.22 → 0.1.24

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+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

@@ -1,6 +1,12 @@
 # SignalK To NFL
 Effortlessly log your boat's movement to **noforeignland.com**
 
+## Testing Notes
+- This version includes experimental features
+- Report issues on GitHub
+- Not recommended for production use
+
+
 ## Features
 * Automatically log your position to NFL
 * Send detailed tracks to log your entire trip and not just your final position

package/index.js

@@ -1,4 +1,3 @@
-
 const { EOL } = require('os');
 const internetTestAddress = 'google.com';
 const internetTestTimeout = 1000;
@@ -8,480 +7,486 @@ 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,
-      },
-      "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
-      },
-      "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.",
-      },
-      "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).",
-      },
-      "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
+const defaultTracksDir = 'track';
+const routeSaveName = 'nfl-track.jsonl';
+
+class SignalkToNoforeignland {
+  constructor(app) {
+    this.app = app;
+    this.pluginId = 'signalk-to-noforeignland';
+    this.pluginName = 'SignalK to Noforeland';
+    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: ['apiCron', '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 (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
+        },
+        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 * * * *'
+        },
+        boatApiKey: {
+          type: 'string',
+          title: 'Boat API key',
+          description: 'Boat API key from noforeignland.com. Can be found in Account > Settings > Boat tracking > API Key.\n*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
+        },
+        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
+        },
+        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.'
+        },
+        trackDir: {
+          type: 'string',
+          title: 'Directory to cache tracks.',
+          description: 'Path in server filesystem, absolute or from plugin directory.\noptional param (only used to keep file cache).'
+        },
+        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
+        },
+        ping_api_every_24h: {
+          type: 'boolean',
+          title: 'Should I 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
+        }
       }
+    };
+  }
+
+  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) {
+    // normalize options
+    this.options = Object.assign({}, options);
+    if (!this.options.trackDir) this.options.trackDir = defaultTracksDir;
+    if (!path.isAbsolute(this.options.trackDir)) {
+      this.options.trackDir = path.join(__dirname, this.options.trackDir);
     }
-  };
 
-  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();
+    if (!this.createDir(this.options.trackDir)) {
+      this.stop();
       return;
     }
 
-    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) {
+    this.app.debug('track logger started, now logging to', this.options.trackDir);
+    this.app.setPluginStatus(`Started`);
+    this.upSince = new Date().getTime();
 
-        for (update of delta.updates) {
-          // app.debug(`update:`, update);
-          if (options.filterSource && update.$source !== 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;
-            }
-            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;
-            }
-          };
-        };
-      }
+    // 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 * * * *`;
     }
 
-    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);
-    }
+    this.app.debug('Setting CRON to ', this.options.apiCron);
 
-    function isValidLatitude(obj) {
-      return isDefinedNumber(obj) && obj > -90 && obj < 90
-    }
+    // subscribe and logging
+    this.doLogging();
 
-    function isValidLongitude(obj) {
-      return isDefinedNumber(obj) && obj > -180 && obj < 180
-    }
+    // start cron job
+    this.cron = new CronJob(this.options.apiCron, this.interval.bind(this));
+    this.cron.start();
+  }
 
-    function isDefinedNumber(obj) {
-      return (obj !== undefined && obj !== null && typeof obj === 'number');
+  stop() {
+    this.app.debug('plugin stopped');
+    if (this.cron) {
+      this.cron.stop();
+      this.cron = undefined;
     }
-
-    // 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;
+    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;
+          }
+          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; 
+            }
+          });
+        });
+      });
     }
+  }
 
-    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;
-        }
+  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;
       }
-      else {
-        try {
-          fs.mkdirSync(dir, { recursive: true });
-        }
-        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;
-          }
-        }
+      
+      // 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;
       }
-      return res;
-    } // end function createDir
 
-    async function interval() {
-      if ((checkBoatMoving()) && await checkTrack() && await testInternet()) {
-        await sendData();
+      // 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;
+        }
       }
-    }
 
-    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;
+      // Wenn wir nicht loggen sollen UND es kein 24h-Force ist, dann raus
+      if (!force24hSave && !getShouldDoLog()) {
+        return;
       }
-    }
 
-    async function testInternet() {
-      app.debug('testing internet connection');
-      const check = await isReachable(internetTestAddress, { timeout: options.internetTestTimeout || internetTestTimeout });
-      app.debug('internet connection = ', check);
-      return check;
-    }
+      // 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;
+        }
+        
+        // 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;
+        }
+      }
 
-    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;
-    }
+      // Punkt speichern
+      this.lastPosition = { pos: value.value, timestamp, currentTime: new Date().getTime() };
+      await this.savePoint(this.lastPosition);
 
-    async function sendData() {
-      if (options.boatApiKey) {
-        sendApiData();
-      } else {
-        sendEmailData();
+      // shouldDoLog zurücksetzen wenn minSpeed aktiv ist
+      if (this.options.minSpeed) {
+        this.app.debug('options.minSpeed - setting shouldDoLog to false');
+        setShouldDoLog(false);
       }
     }
+  }}
 
-    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
+ 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);
+  
+  // Inform user about last saved point
+  const lastSaveTime = new Date().toLocaleString();
+  const lastTransferTime = this.lastSuccessfulTransfer ? this.lastSuccessfulTransfer.toLocaleString() : 'Never';
+  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;
       }
-
-      app.debug('sending track to API');
+    } else {
       try {
-        const response = await fetch(apiUrl, { method: 'POST', body: params, headers: new fetch.Headers(headers) });
-        if (response.ok) {
-          const responseBody = await response.json();
-          if (responseBody.status === 'ok') {
-            app.debug('Track successfully sent to API');
-            if (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));
-            } else {
-              app.debug('Deleting track file');
-              await fs.remove(path.join(options.trackDir, routeSaveName));
-            }
-          } else {
-            app.debug('Could not send track to API, returned response json:', responseBody);
-          }
-        } else {
-          app.debug('Could not send track to API, returned response code:', response.status, response.statusText);
+        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;
         }
-      } catch (err) {
-        app.debug('Could not send track to API due to error:', err);
       }
     }
+    return res;
+  }
 
-    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);
+  // periodic interval called by cron
+  async interval() {
+    if ((this.checkBoatMoving()) && await this.checkTrack() && await this.testInternet()) {
+      await this.sendData();
+    }
+  }
+
+  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');
+  
+  try {
+    // Force IPv4 DNS lookup with timeout
+    const timeoutMs = this.options.internetTestTimeout || internetTestTimeout;
+    const addresses = await Promise.race([
+      dns.resolve4(internetTestAddress),
+      new Promise((_, reject) => 
+        setTimeout(() => reject(new Error('DNS timeout')), timeoutMs)
+      )
+    ]);
+    
+    if (addresses && addresses.length > 0) {
+      this.app.debug('internet connection = true, resolved IPv4:', addresses[0]);
+      return true;
+    } else {
+      this.app.debug('internet connection = false, no IPv4 addresses found');
+      return false;
+    }
+  } catch (err) {
+    this.app.debug('internet connection = false, error:', err.message);
+    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 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');
+
+    try {
+      const response = await fetch(apiUrl, { method: 'POST', body: params, headers: new fetch.Headers(headers) });
+      if (response.ok) {
+        const responseBody = await response.json();
+        if (responseBody.status === 'ok') {
+          this.lastSuccessfulTransfer = new Date();
+          this.app.debug('Track successfully sent to API');
+          this.app.setPluginStatus(`Started - last Track sent successfully at ${new Date().toLocaleString()}`);
+          if (this.options.keepFiles) {
+            const filename = new Date().toJSON().slice(0, 19).replace(/:/g, '') + '-nfl-track.jsonl';
+            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 {
+            this.app.debug('Deleting track file');
+            await fs.remove(path.join(this.options.trackDir, routeSaveName));
           }
+        } else {
+          this.app.debug('Could not send track to API, returned response json:', responseBody);
+          this.app.setPluginError(`Failed to send track - check logs for details.`);
         }
+      } else {
+        this.app.debug('Could not send track to API, returned response code:', response.status, response.statusText);
+        this.app.setPluginError(`Failed to send track - check logs for details.`);
       }
-      if (track.length > 0) {
-        return { timestamp: new Date(lastTimestamp).getTime(), track };
-      }
+    } catch (err) {
+      this.app.debug('Could not send track to API due to error:', err);
+      this.app.setPluginError(`Failed to send track - check logs for details.`);
     }
-
-    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.24",
   "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;