Update fronend to v0.1.0-beta9

- Update grafana role SQl connection to 30
- Alter moorages table with default duration of 0. Affect views
- Update moorage_view to default with duration of 0
- Create a every 15 minutes for cron_process_new_video_fn
- Update video_ready email template
- Reduce debug on public.qgis_getmap_py_fn
- Update public.qgis_bbox_py, add more parameters to allow use case.
- Create role qgis_role with RLS
- Create role maplapse_role with RLS
- Update notification, add video link and log image link for public.send_email_py_fn, public.send_pushover_py_fn, public.send_telegram_py_fn

.codesandbox/tasks.json

@@ -0,0 +1,114 @@
+{
+  // These tasks will run in order when initializing your CodeSandbox project.
+  "setupTasks": [
+    {
+      "name": "git udpate",
+      "command": "cd ~/workspace/ && git pull"
+    },
+    {
+      "name": "git udpate submodule",
+      "command": "cd ~/workspace/ && git submodule update --recursive --remote"
+    }
+  ],
+
+  // These tasks can be run from CodeSandbox. Running one will open a log in the app.
+  "tasks": {
+    "docker-compose up db": {
+      "name": "docker-compose up db",
+      "command": "docker-compose up db",
+      "runAtStart": true
+    },
+    "docker network inspect network": {
+      "name": "docker network inspect postgsail_default",
+      "command": "docker network ls && docker network inspect postgsail_default",
+      "runAtStart": false
+    },
+    "docker-compose up api": {
+      "name": "docker-compose up api",
+      "command": "docker-compose up api",
+      "runAtStart": false,
+      "preview": {
+        "port": 3000,
+        "prLink": "direct"
+      }
+    },
+    "docker volume rm volume": {
+      "name": "docker volume rm volume",
+      "command": "docker volume ls && docker volume rm postgsail_data",
+      "runAtStart": false
+    },
+    "docker-compose rm db": {
+      "name": "docker-compose rm db",
+      "command": "docker-compose rm db",
+      "runAtStart": false
+    },
+    "docker-compose rm api": {
+      "name": "docker-compose rm api",
+      "command": "docker-compose rm api",
+      "runAtStart": false
+    },
+    "docker-compose clean": {
+      "name": "docker-compose clean",
+      "command": "docker-compose stop && docker-compose rm && docker volume ls && docker volume rm postgsail_data",
+      "runAtStart": false
+    },
+    "docker-compose pgadmin": {
+      "name": "docker-compose up pgadmin",
+      "command": "docker-compose up pgadmin",
+      "runAtStart": false,
+      "preview": {
+        "port": 5050,
+        "prLink": "direct"
+      }
+    },
+    "docker-compose web": {
+      "name": "docker-compose up web",
+      "command": "docker-compose up web",
+      "runAtStart": false,
+      "preview": {
+        "port": 8080,
+        "prLink": "direct"
+      }
+    },
+    "docker-compose ps": {
+      "name": "docker-compose ps -a",
+      "command": "docker-compose ps -a",
+      "runAtStart": false
+    },
+    "docker ps": {
+      "name": "docker ps -a",
+      "command": "docker ps -a",
+      "runAtStart": false
+    },
+    "docker-compose stop": {
+      "name": "docker-compose stop",
+      "command": "docker-compose stop",
+      "runAtStart": false
+    },
+    "npm i": {
+      "name": "npm i",
+      "command": "cd frontend/ && npm i",
+      "runAtStart": false
+    },
+    "git submodule add https://github.com/xbgmsharp/vuestic-postgsail frontend": {
+      "name": "git submodule add https://github.com/xbgmsharp/vuestic-postgsail frontend",
+      "command": "git submodule add https://github.com/xbgmsharp/vuestic-postgsail frontend",
+      "runAtStart": false
+    },
+    "git submodule update --init --recursive": {
+      "name": "git submodule update --init --recursive",
+      "command": "git submodule update --init --recursive",
+      "runAtStart": false
+    },
+    "git submodule update --recursive --remote": {
+      "name": "git submodule update --recursive --remote",
+      "command": "git submodule update --recursive --remote",
+      "runAtStart": false
+    },
+    "git pull": {
+      "name": "git pull",
+      "command": "git pull",
+      "runAtStart": false
+    }
+  }
+}

.devcontainer.json

@@ -0,0 +1,76 @@
+{
+  "name": "PostgSail",
+  //"image": "mcr.microsoft.com/devcontainers/base:alpine",
+  "dockerComposeFile": ["docker-compose.dev.yml", "docker-compose.yml"],
+  "service": "dev",
+  "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
+
+  // Use this environment variable if you need to bind mount your local source code into a new container.
+  "remoteEnv": {
+    "LOCAL_WORKSPACE_FOLDER": "${localWorkspaceFolder}",
+    "POSTGRES_PASSWORD": "${localEnv:POSTGRES_PASSWORD}",
+    "POSTGRES_USER": "${localEnv:POSTGRES_USER}",
+    "POSTGRES_DB": "${localEnv:POSTGRES_DB}",
+    "PGSAIL_AUTHENTICATOR_PASSWORD": "${localEnv:PGSAIL_AUTHENTICATOR_PASSWORD}"
+  },
+  "containerEnv": {
+    //"GITHUB_TOKEN": "${localEnv:GITHUB_TOKEN}",
+    //"GITHUB_USER": "${localEnv:GITHUB_USER}"
+  },
+
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  // "features": {},
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+  "forwardPorts": ["db:5432", "api:3000", "pgadmin:5050", "web:8080"],
+
+  // Use 'portsAttributes' to set default properties for specific forwarded ports.
+  // More info: https://containers.dev/implementors/json_reference/#port-attributes
+  "portsAttributes": {
+    "3000": {
+      "label": "api",
+      "onAutoForward": "notify"
+    },
+    "5050": {
+      "label": "pgadmin",
+      "onAutoForward": "notify"
+    },
+    "5342": {
+      "label": "database",
+      "onAutoForward": "notify"
+    },
+    "8080": {
+      "label": "web",
+      "onAutoForward": "notify"
+    }
+  },
+
+  // Use 'postCreateCommand' to run commands after the container is created.
+  // "postCreateCommand": "docker --version",
+
+  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+  // "remoteUser": "root"
+
+  // Configure tool-specific properties.
+  "customizations": {
+    // Configure properties specific to VS Code.
+    "vscode": {
+      "settings": {
+        "terminal.integrated.profiles.linux": {
+          "zsh": {
+            "path": "/bin/bash"
+          }
+        },
+        "terminal.integrated.defaultProfile.linux": "bash",
+        "editor.formatOnSave": true
+      },
+      "extensions": [
+        "streetsidesoftware.code-spell-checker",
+        "esbenp.prettier-vscode",
+        "ckolkman.vscode-postgres",
+        "ms-azuretools.vscode-docker"
+      ]
+    }
+  }
+}

.env.example

@@ -6,17 +6,23 @@ POSTGRES_DB=postgres
 PGSAIL_AUTHENTICATOR_PASSWORD=password
 PGSAIL_GRAFANA_PASSWORD=password
 PGSAIL_GRAFANA_AUTH_PASSWORD=password
+# SMTP server settings
 PGSAIL_EMAIL_FROM=root@localhost
 PGSAIL_EMAIL_SERVER=localhost
 #PGSAIL_EMAIL_USER= Comment if not use
 #PGSAIL_EMAIL_PASS= Comment if not use
+# Pushover settings
 #PGSAIL_PUSHOVER_APP_TOKEN= Comment if not use
 #PGSAIL_PUSHOVER_APP_URL= Comment if not use
+# TELEGRAM BOT, ask BotFather
 #PGSAIL_TELEGRAM_BOT_TOKEN= Comment if not use
-PGSAIL_APP_URL=http://localhost
-PGSAIL_API_URL=http://localhost
+# webapp entrypoint, typically the public DNS or IP
+PGSAIL_APP_URL=http://localhost:8080
+# API entrypoint from the webapp, typically the public DNS or IP
+PGSAIL_API_URL=http://localhost:3000
 # POSTGREST ENV Settings
-PGRST_DB_URI=postgres://authenticator:${PGSAIL_AUTHENTICATOR_PASSWORD}@127.0.0.1:5432/signalk
+PGRST_DB_URI=postgres://authenticator:${PGSAIL_AUTHENTICATOR_PASSWORD}@db:5432/signalk
+# % cat /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' | fold -w 42 | head -n 1
 PGRST_JWT_SECRET=_at_least_32__char__long__random
 # Grafana ENV Settings
 GF_SECURITY_ADMIN_PASSWORD=password

.github/FUNDING.yml

@@ -0,0 +1,14 @@
+# These are supported funding model platforms
+
+github: [xbgmsharp]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+  # Enable version updates for Docker
+  - package-ecosystem: "docker"
+    # Look for a `Dockerfile` in the `root` directory
+    directory: "/"
+    # Check for updates once a week
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly

.github/workflows/db-lint.yml

@@ -0,0 +1,55 @@
+name: Linting rules on database schema.
+
+on:
+  pull_request:
+    paths:
+      - 'initdb/**'
+    branches:
+      - 'main'
+  push:
+    branches:
+      - 'main'
+    paths:
+      - 'initdb/**'
+    tags:
+        - "*"
+  workflow_dispatch:
+
+jobs:
+  schemalint:
+    name: schemalint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the source
+        uses: actions/checkout@v4
+
+      - name: Set env
+        run: cp .env.example .env
+
+      - name: Pull Docker images
+        run: docker-compose pull db api
+
+      - name: Run PostgSail Database & schemalint
+        # Environment variables
+        env:
+          # The hostname used to communicate with the PostgreSQL service container
+          PGHOST: localhost
+          PGPORT: 5432
+          PGDATABASE: signalk
+          PGUSER: username
+          PGPASSWORD: password
+        run: |
+          set -eu
+          source .env
+          docker-compose stop || true
+          docker-compose rm || true
+          docker-compose up -d db && sleep 30 && docker-compose up -d api && sleep 5
+          docker-compose ps -a
+          echo ${PGSAIL_API_URL}
+          curl ${PGSAIL_API_URL}
+          npm i -D schemalint
+          npx schemalint
+      - name: Show the logs
+        if: always()
+        run: |
+          docker-compose logs

.github/workflows/db-test.yml

@@ -0,0 +1,73 @@
+name: Test services db, api
+
+on:
+  pull_request:
+    paths:
+      - 'initdb/**'
+      - 'tests/**'
+    branches:
+      - 'main'
+  push:
+    branches:
+      - 'main'
+    paths:
+      - 'initdb/**'
+      - 'tests/**'
+    tags:
+        - "*"
+  workflow_dispatch:
+
+jobs:
+  smoketest:
+    name: tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the source
+        uses: actions/checkout@v4
+
+      - name: Set env
+        run: cp .env.example .env
+
+      - name: Pull Docker images
+        run: docker-compose pull db api
+
+      - name: Build Docker images
+        run: docker-compose -f docker-compose.dev.yml -f docker-compose.yml build tests
+
+      - name: Install psql
+        run: sudo apt install postgresql-client
+
+      - name: Run PostgSail Database & API tests
+        # Environment variables
+        env:
+          # The hostname used to communicate with the PostgreSQL service container
+          PGHOST: localhost
+          PGPORT: 5432
+          PGDATABASE: signalk
+          PGUSER: username
+          PGPASSWORD: password
+        run: |
+          set -eu
+          source .env
+          docker-compose stop || true
+          docker-compose rm || true
+          docker-compose up -d db && sleep 30 && docker-compose up -d api && sleep 5
+          docker-compose ps -a
+          echo ${PGSAIL_API_URL}
+          curl ${PGSAIL_API_URL}
+          psql -c "select 1"
+          echo "Test PostgreSQL version"
+          psql -c "SELECT version();"
+          echo "Test PostgSail version"
+          psql -c "SELECT value FROM app_settings WHERE name = 'app.version';"
+          echo "Test PostgSail Unit Test"
+          docker compose -f docker-compose.dev.yml -f docker-compose.yml up tests --abort-on-container-exit --exit-code-from tests
+          if [ $? != 0 ];
+          then
+              echo "Error running db-tests"
+              exit 1
+          fi
+      - name: Show the logs
+        if: always()
+        run: |
+          docker-compose logs

.github/workflows/frontend-test.yml

@@ -0,0 +1,70 @@
+name: Test services db, api, web
+
+on:
+  pull_request:
+    paths:
+      - 'frontend/**'
+    branches:
+      - 'main'
+  push:
+    branches:
+      - 'main'
+    paths:
+      - 'frontend/**'
+    tags:
+      - "*"
+  workflow_dispatch:
+
+jobs:
+  ci-test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: 'true'
+
+      - name: Set env
+        run: cp .env.example .env
+
+      - name: Pull Docker images
+        run: docker compose -f docker-compose.dev.yml -f docker-compose.yml pull db api web_tests
+
+      - name: Build Docker images
+        run: |
+          set -eu
+          source .env
+          docker compose -f docker-compose.dev.yml -f docker-compose.yml build web_dev
+          docker compose -f docker-compose.dev.yml -f docker-compose.yml build web
+
+      - name: Run PostgSail Web tests
+        # Environment variables
+        env:
+          # The hostname used to communicate with the PostgreSQL service container
+          PGHOST: localhost
+          PGPORT: 5432
+          PGDATABASE: signalk
+          PGUSER: username
+          PGPASSWORD: password
+        run: |
+          set -eu
+          source .env
+          docker-compose stop || true
+          docker-compose rm || true
+          docker-compose up -d db && sleep 30 && docker-compose up -d api && sleep 5
+          docker-compose ps -a
+          echo "Test PostgSail Web Unit Test"
+          docker compose -f docker-compose.dev.yml -f docker-compose.yml up -d web_dev && sleep 100
+          docker compose -f docker-compose.dev.yml -f docker-compose.yml logs web_dev
+          docker compose ps -a
+          curl http://localhost:8080/
+          docker compose -f docker-compose.dev.yml -f docker-compose.yml up web_tests --abort-on-container-exit --exit-code-from web_tests
+          if [ $? != 0 ];
+          then
+              echo "Error running frontend-tests"
+              exit 1
+          fi
+      - name: Show the logs
+        if: always()
+        run: |
+          docker-compose logs

.github/workflows/grafana-test.yml

@@ -0,0 +1,54 @@
+name: Test services db, grafana
+
+on:
+  pull_request:
+    paths:
+      - 'grafana/**'
+    branches:
+      - 'main'
+  push:
+    branches:
+      - 'main'
+    paths:
+      - 'grafana/**'
+    tags:
+      - "*"
+  workflow_dispatch:
+
+jobs:
+  ci-test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set env
+        run: cp .env.example .env
+
+      - name: Pull Docker images
+        run: docker-compose pull db app
+
+      - name: Run PostgSail Grafana test
+        # Environment variables
+        env:
+          # The hostname used to communicate with the PostgreSQL service container
+          PGHOST: localhost
+          PGPORT: 5432
+          PGDATABASE: signalk
+          PGUSER: username
+          PGPASSWORD: password
+        run: |
+          set -eu
+          source .env
+          docker-compose stop || true
+          docker-compose rm || true
+          docker-compose up -d db && sleep 30
+          docker-compose ps -a
+          echo "Test PostgSail Grafana Unit Test"
+          docker-compose up -d app && sleep 5
+          docker-compose ps -a
+          curl http://localhost:3001/
+      - name: Show the logs
+        if: always()
+        run: |
+          docker-compose logs

.gitignore

@@ -1,2 +1,10 @@
 .DS_Store
 .env
+initdb/*.csv
+initdb/*.no
+initdb/*.jwk
+tests/node_modules/
+tests/output/
+assets/*
+.pnpm-store/
+db-data/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "frontend"]
+	path = frontend
+	url = https://github.com/xbgmsharp/vuestic-postgsail

.schemalintrc.js

@@ -0,0 +1,22 @@
+module.exports = {
+    connection: {
+      host: process.env.PGHOST,
+      user: process.env.PGUSER,
+      password: process.env.PGPASSWORD,
+      database: process.env.PGDATABASE,
+      charset: "utf8",
+    },
+
+    rules: {
+      "name-casing": ["error", "snake"],
+      "prefer-jsonb-to-json": ["error"],
+      "prefer-text-to-varchar": ["error"],
+      "prefer-timestamptz-to-timestamp": ["error"],
+      "prefer-identity-to-serial": ["error"],
+      //"name-inflection": ["error", "singular"],
+    },
+
+    schemas: [{ name: "public" }, { name: "api" },{ name: "auth" }],
+
+    ignores: [],
+  };

CHANGELOG.md

@@ -0,0 +1 @@
+## Please see [Releases](https://github.com/xbgmsharp/postgsail/releases) for the release notes.

CODE_OF_CONDUCT.md

@@ -0,0 +1,45 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to make participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when an individual is representing the project or its community in public spaces. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project maintainer using any of the [private contact addresses](https://github.com/dec0dOS/amazing-github-template#support). All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org), version 1.4, available at <https://www.contributor-covenant.org/version/1/4/code-of-conduct.html>
+
+For answers to common questions about this code of conduct, see <https://www.contributor-covenant.org/faq>

CONTRIBUTING.md

@@ -0,0 +1,3 @@
+Styleguides
+
+Ensure you code is in lint formatting.

ERD/README.md

@@ -1,35 +0,0 @@
-# PostgSail ERD
-The Entity-Relationship Diagram (ERD) provides a graphical representation of database tables, columns, and inter-relationships. ERD can give sufficient information for the database administrator to follow when developing and maintaining the database.
-
-## A global overview
-![API Schema](https://raw.githubusercontent.com/xbgmsharp/postgsail/main/ERD/postgsail.pgerd.png "API Schema")
-
-## Further
-There is 3 main schemas:
-- API Schema ERD
-    - tables
-      - metrics
-      - logbook
-      - ...
-    - functions
-      - ...
-![API Schema](https://raw.githubusercontent.com/xbgmsharp/postgsail/main/ERD/signalk%20-%20api.png)
-
-- Auth Schema ERD
-  - tables
-    - accounts
-    - vessels
-    - ...
-  - functions
-    - ...
-![Auth Schema](https://raw.githubusercontent.com/xbgmsharp/postgsail/main/ERD/signalk%20-%20auth.png "Auth Schema")
-
-- Public Schema ERD
-  - tables
-    - app_settings
-    - tpl_messages
-    - ...
-  - functions
-    - ...
-![Public Schema](https://raw.githubusercontent.com/xbgmsharp/postgsail/main/ERD/signalk%20-%20public.png "Public Schema")
-

README.md

@@ -1,145 +1,146 @@
-# PostgSail
+<br/>
+<p align="center">
+  <a href="https://github.com/xbgmsharp/postgsail">
+    <img src="https://iot.openplotter.cloud/android-chrome-192x192.png" alt="Logo" width="80" height="80">
+  </a>
+
+  <h3 align="center">PostgSail</h3>
+
+  <p align="center">
+    PostgSail is an open-source alternative to traditional vessel data management!
+    <br/>
+    <br/>
+    <a href="https://github.com/xbgmsharp/postgsail/blob/main/docs/README.md"><strong>Explore the docs »</strong></a>
+    <br/>
+    <br/>
+    <a href="#about-the-project">View Demo</a>
+    .
+    <a href="https://github.com/xbgmsharp/postgsail/issues">Report Bug</a>
+    .
+    <a href="https://github.com/xbgmsharp/postgsail/issues">Request Feature</a>
+    .
+    <a href="https://xbgmsharp.github.io/postgsail/">Website</a>
+    .
+    <a href="https://github.com/sponsors/xbgmsharp">Sponsors</a>
+    .
+    <a href="https://discord.gg/uuZrwz4dCS">Discord</a>
+  </p>
+</p>
+
+[![release](https://img.shields.io/github/release/xbgmsharp/postgsail?include_prereleases=&sort=semver&color=blue)](https://github.com/xbgmsharp/postgsail/releases/latest)
+[![License](https://img.shields.io/github/license/xbgmsharp/postgsail)](#license)
+[![issues - postgsail](https://img.shields.io/github/issues/xbgmsharp/postgsail)](https://github.com/xbgmsharp/postgsail/issues)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+![Contributors](https://img.shields.io/github/contributors/xbgmsharp/postgsail?color=dark-green) 
+
+[![Test services db, api](https://github.com/xbgmsharp/postgsail/actions/workflows/db-test.yml/badge.svg)](https://github.com/xbgmsharp/postgsail/actions/workflows/db-test.yml)
+[![Test services db, api, web](https://github.com/xbgmsharp/postgsail/actions/workflows/frontend-test.yml/badge.svg)](https://github.com/xbgmsharp/postgsail/actions/workflows/frontend-test.yml)
+[![Test services db, grafana](https://github.com/xbgmsharp/postgsail/actions/workflows/grafana-test.yml/badge.svg)](https://github.com/xbgmsharp/postgsail/actions/workflows/grafana-test.yml)
+
+signalk-postgsail:
+[![GitHub Release](https://img.shields.io/github/release/xbgmsharp/signalk-postgsail.svg)](https://github.com/xbgmsharp/signalk-postgsail/releases/latest)
+
+postgsail-frontend:
+[![GitHub Release](https://img.shields.io/github/release/xbgmsharp/vuestic-postgsail.svg)](https://github.com/xbgmsharp/vuestic-postgsail/releases/latest)
+
+postgsail-telegram-bot:
+[![GitHub Release](https://img.shields.io/github/release/xbgmsharp/postgsail-telegram-bot.svg)](https://github.com/xbgmsharp/postgsail-telegram-bot/releases/latest)
+
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/8124/badge)](https://www.bestpractices.dev/projects/8124)
+
+
+## Table Of Contents
+
+- [Table Of Contents](#table-of-contents)
+- [About The Project](#about-the-project)
+- [Features](#features)
+- [Cloud-hosted PostgSail](#cloud-hosted-postgsail)
+- [On-Premise (for free)](#on-premise-for-free)
+- [Roadmap](#roadmap)
+- [Contributing](#contributing)
+  - [Creating A Pull Request](#creating-a-pull-request)
+- [License](#license)
+- [Acknowledgements](#acknowledgements)
+
+## About The Project
+
+https://github.com/xbgmsharp/signalk-postgsail/assets/1498985/b2669c39-11ad-4a50-9f91-9397f9057ee8
+
 Effortless cloud based solution for storing and sharing your SignalK data. Allow you to effortlessly log your sails and monitor your boat with historical data.
 
-## Features
-- Automatically log your voyages without manually starting or stopping a trip.
-- Automatically capture the details of your voyages (boat speed, heading, wind speed, etc).
-- Timelapse video your trips!
-- Add custom notes to your logs.
-- Export to CSV or GPX and download your logs.
-- Aggregate your trip statistics: Longest voyage, time spent at anchorages, home ports etc.
-- See your moorages on a global map, with incoming and outgoing voyages from each trip.
-- Monitor your boat (position, depth, wind, temperature, battery charge status, etc.) remotely.
-- History: view trends.
-- Alert monitoring: get notification on low voltage or low fuel remotely.
-- Notification via email or PushOver, Telegram
-- Offline mode
-- Low Bandwith mode
+Here's how:
 
-## Context
 It is all about SQL, object-relational, time-series, spatial databases with a bit of python.
 
 PostgSail is an open-source alternative to traditional vessel data management.
 It is based on a well known open-source technology stack, Signalk, PostgreSQL, TimescaleDB, PostGIS, PostgREST. It does perfectly integrate with standard monitoring tool stack like Grafana.
 
-To understand the why and how, you might want to read [Why.md](https://github.com/xbgmsharp/postgsail/tree/main/Why.md)
+To understand the why and how, you might want to read [Why.md](https://github.com/xbgmsharp/postgsail/blob/main/Why.md)
 
-## Architecture
-For more clarity and visibility the complete [Entity-Relationship Diagram (ERD)](https://github.com/xbgmsharp/postgsail/tree/main/ERD/README.md) is export as PNG and SVG file.
+## Features
 
-### Cloud
-If you prefer not to install or administer your instance of PostgSail, hosted versions of PostgSail are available in the cloud of your choice.
+- Automatically log your voyages without manually starting or stopping a trip.
+- Automatically capture the details of your voyages (boat speed, heading, wind speed, etc).
+- Timelapse video your trips, with or without time control.
+- Add custom notes to your logs.
+- Export to CSV, GPX, GeoJSON, KML and download your logs.
+- Export your logs as image (PNG) or video (MP4).
+- Aggregate your trip statistics: Longest voyage, time spent at anchorages, home ports etc.
+- See your moorages on a global map, with incoming and outgoing voyages from each trip.
+- Monitor your boat (position, depth, wind, temperature, battery charge status, etc.) remotely.
+- History: view trends.
+- Alert monitoring: get notification on low voltage or low fuel remotely.
+- Notification via email or PushOver, Telegram.
+- Offline mode.
+- Low Bandwidth mode.
+- Awesome statistics and graphs.
+- Create and manage your own dashboards.
+- Windy PWS (Personal Weather Station).
+- Engine Hours Logger.
+- Polar performance.
+- Anything missing? just ask!
 
-The cloud advantage.
+## Cloud-hosted PostgSail
 
-Hosted and fully–managed options for PostgSail, designed for all your deployment and business needs. Register and try for free at https://iot.openplotter.cloud/.
+Remove the hassle of running PostgSail yourself. Here you can skip the technical setup, the maintenance work and server costs by getting PostgSail on our reliable and secure PostgSail Cloud. Register and try for free at [iot.openplotter.cloud](https://iot.openplotter.cloud/).
 
-## Using PostgSail
-### pre-deploy configuration
+## On-Premise (for free)
 
-To get these running, copy `.env.example` and rename to `.env` then set the value accordinly.
+Self host postgSail where you want and how you want. There are no restrictions, you’re in full control. [Install Guide](https://github.com/xbgmsharp/postgsail/blob/main/docs/README.md)
 
-Notice, that `PGRST_JWT_SECRET` must be at least 32 characters long.
+## Roadmap
 
-`$ head /dev/urandom | tr -dc A-Za-z0-9 | head -c 32 ; echo ''`
+See the [open issues](https://github.com/xbgmsharp/postgsail/issues) for a list of proposed features (and known issues).
 
-### Deploy
-By default there is no network set and the postgresql data are store in a docker volume.
-You can update the default settings by editing `docker-compose.yml` to your need.
-Then simply excecute:
-```bash
-$ docker-compose up
-```
+Join the community, Get support and exchange on [Discord](https://discord.gg/uuZrwz4dCS). Missing a feature? just ask!
 
-### SQL Configuration
+## Contributing
 
-Check and update your postgsail settings via SQL in the table `app_settings`:
+Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+* If you have suggestions for features, feel free to [open an issue](https://github.com/xbgmsharp/postgsail/issues/new) to discuss it, or directly create a pull request with necessary changes.
+* Please make sure you check your spelling and grammar.
+* Create individual PR for each suggestion.
+* Please also read through the [Code Of Conduct](https://github.com/xbgmsharp/postgsail/blob/main/CODE_OF_CONDUCT.md) before posting your first idea as well.
 
-```sql
-SELECT * FROM app_settings;
-```
+### Creating A Pull Request
 
-```sql
-UPDATE app_settings
-    SET
-        value = 'new_value'
-    WHERE name = 'app.email_server';
-```
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the Branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
 
-### Ingest data
-Next, to ingest data from signalk, you need to install [signalk-postgsail](https://github.com/xbgmsharp/signalk-postgsail) plugin on your signalk server instance.
+## License
 
-Also, if you like, you can import saillogger data using the postgsail helpers, [postgsail-helpers](https://github.com/xbgmsharp/postgsail-helpers).
+Distributed under the Apache License Version 2.0. See [LICENSE](https://github.com/xbgmsharp/postgsail/blob/main/LICENSE) for more information.
 
-You might want to import your influxdb1 data as well, [outflux](https://github.com/timescale/outflux).
-Any taker on influxdb2 to PostgSail? It is definitly possible.
+## Acknowledgements
 
-Last, if you like, you can import the sample data from Signalk NMEA Plaka by running the tests.
-If everything goes well all tests pass sucessfully and you should recieve a few notifications by email or PushOver.
-```
-$ docker-compose up tests
-```
+An out of the box IoT platform using Docker (could be extend to K3 or K8) with the following software:
 
-### API Documentation
-The OpenAPI description output depends on the permissions of the role that is contained in the JWT role claim.
-
-API anonymous:
-```
-$ curl http://localhost:3000/
-```
-
-API user_role:
-```
-$ curl http://localhost:3000/ -H 'Authorization: Bearer my_token_from_login_or_signup_fn'
-```
-
-API vessel_role:
-```
-$ curl http://localhost:3000/ -H 'Authorization: Bearer my_token_from_register_vessel_fn'
-```
-
-#### API main workflow
-
-Check the [unit test sample](https://github.com/xbgmsharp/postgsail/blob/main/tests/index.js).
-
-### Docker dependencies
-
-`docker-compose` is used to start environment dependencies. Dependencies consist of 3 containers:
-
-- `timescaledb-postgis` alias `db`, PostgreSQL with TimescaleDB extension along with the PostGIS extension.
-- `postgrest` alias `api`, Standalone web server that turns your PostgreSQL database directly into a RESTful API.
-- `grafana` alias `app`, visualize and monitor your data
-
-### Optional docker images
-
-- [pgAdmin](https://hub.docker.com/r/dpage/pgadmin4), web UI to monitor and manage multiple PostgreSQL
-- [Swagger](https://hub.docker.com/r/swaggerapi/swagger-ui), web UI to visualize documentation from PostgREST
-```
-docker-compose -f docker-compose-optional.yml up
-```
-
-### Software reference
-Out of the box iot platform using docker with the following software:
 - [Signal K server, a Free and Open Source universal marine data exchange format](https://signalk.org)
 - [PostgreSQL, open source object-relational database system](https://postgresql.org)
 - [TimescaleDB, Time-series data extends PostgreSQL](https://www.timescale.com)
 - [PostGIS, a spatial database extender for PostgreSQL object-relational database.](https://postgis.net/)
 - [Grafana, open observability platform | Grafana Labs](https://grafana.com)
-
-### Releases & updates
-PostgSail Release Notes & Future Plans: see planned and in-progress updates and detailed information about current and past releases. [PostgSail project](https://github.com/xbgmsharp?tab=projects)
-
-### Support
-
-To get support, please create new [issue](https://github.com/xbgmsharp/postgsail/issues).
-
-There is more likely security flows and bugs.
-
-### Contribution
-
-I'm happy to accept Pull Requests!
-Feel free to contribute.
-
-### License
-
-This script is free software, Apache License Version 2.0.
+- And many more

Why.md

@@ -1,11 +1,15 @@
 
 #### Why not InfluxDB vs TimescaleDB
-I had an InfluxDBv1 on my RPI that kill the sdcard. I had an InfluxDBv2, but no more ARM support and had to learn flux. Also could not find a good way to store data when offline. How do you export your data from a InfluxDBv2? Still looking for a solution.
+I had an InfluxDBv1 on my RPI that kill the sdcard/usbkey. I had an InfluxDBv2, but there is no more ARM support and had to learn flux. Also could not find a good way to store data when offline. How do you export your data from a InfluxDBv2? Still looking for a solution.
 
-With TimescaleDB, we all ready know SQL and there is a lot of tools and librairies that work with Postgres.
+With TimescaleDB, we already know SQL and there is a lot of tools and libraries that work with Postgres.
 However, InfluxDB does simplify things like schema and provide an http endpoint.
 With TimescaleDB, you are using a standard SQL table schema to store data from Signalk.
 
 #### Why not MQTT vs HTTP 
-Having MQTT, makes your application micro service approach. however you multiple the compoments and dependecy. HTTP seem a more realibale solution specaily for offline support as MQTT library have a buffer limitation.
+Having MQTT, makes your application micro service approach. however you multiple the components and dependency. HTTP seem a more reliable solution specially for offline support as MQTT library have a buffer limitation.
 Using PostgREST is an alternative to manual CRUD programming. Custom API servers suffer problems. Writing business logic often duplicates, ignores or hobbles database structure. Object-relational mapping is a leaky abstraction leading to slow imperative code. The PostgREST philosophy establishes a single declarative source of truth: the data itself.
+
+#### PostgreSQL got it all!
+No additional dependencies other than PostgreSQL, thanks to the extensions ecosystem.
+With PostgSail is based on PostGis and TimescaleDB and a few other pg extensions, https://github.com/xbgmsharp/timescaledb-postgis, fore more details.

docker-compose.dev.yml

@@ -0,0 +1,135 @@
+version: "3.9"
+
+services:
+  dev:
+    container_name: dev
+    image: mcr.microsoft.com/devcontainers/base:ubuntu
+    volumes:
+      - ../:/workspaces:cached
+      - /var/run/docker.sock:/var/run/docker.sock
+    #network_mode: service:db
+    links:
+      - "api:postgrest"
+      - "db:database"
+      #- "web_dev:web_dev"
+    command: sleep infinity
+
+  pgadmin:
+    image: dpage/pgadmin4:latest
+    container_name: pgadmin
+    restart: unless-stopped
+    volumes:
+      - data:/var/lib/pgadmin
+      - ./pgadmin_servers.json:/servers.json:ro
+    links:
+      - "db:database"
+    ports:
+      - 5050:5050
+    environment:
+      - PGADMIN_DEFAULT_EMAIL=${PGADMIN_DEFAULT_EMAIL}
+      - PGADMIN_DEFAULT_PASSWORD=${PGADMIN_DEFAULT_PASSWORD}
+      - PGADMIN_LISTEN_ADDRESS=0.0.0.0
+      - PGADMIN_LISTEN_PORT=5050
+      - PGADMIN_SERVER_JSON_FILE=/servers.json
+      - PGADMIN_DISABLE_POSTFIX=true
+    depends_on:
+      - db
+    logging:
+      options:
+        max-size: 10m
+
+  swagger:
+    image: swaggerapi/swagger-ui
+    container_name: swagger
+    restart: unless-stopped
+    links:
+      - "api:postgrest"
+    ports:
+      - "8181:8080"
+    expose:
+      - "8080"
+    environment:
+      - API_URL=http://api:3000/
+    depends_on:
+      - db
+      - api
+    logging:
+      options:
+        max-size: 10m
+
+  tests:
+    image: xbgmsharp/postgsail-tests
+    build:
+      context: ./tests
+      dockerfile: Dockerfile
+    container_name: tests
+    volumes:
+      - ./tests:/mnt
+    working_dir: /mnt
+    command: 'bash tests.sh'
+    links:
+      - "api:postgrest"
+      - "db:database"
+    env_file: .env
+    environment:
+      - POSTGRES_USER=${POSTGRES_USER}
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
+      - PGPASSWORD=${POSTGRES_PASSWORD}
+      - PGSAIL_API_URI=http://api:3000
+      - PGSAIL_DB_URI=postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/signalk
+    depends_on:
+      - db
+      - api
+    logging:
+      options:
+        max-size: 10m
+
+  web_dev:
+    image: xbgmsharp/postgsail-vuestic:dev
+    build:
+      context: https://github.com/xbgmsharp/vuestic-postgsail.git#live
+      dockerfile: Dockerfile_dev
+    container_name: web_dev
+    hostname: web_dev
+    restart: unless-stopped
+    volumes:
+      - ./frontend:/app
+    links:
+      - "api:postgrest"
+    ports:
+      - 8080:8080
+    env_file: .env
+    environment:
+      - VITE_PGSAIL_URL=http://api:3000
+      - VITE_APP_INCLUDE_DEMOS=false
+      - VITE_APP_BUILD_VERSION=true
+      - VITE_APP_TITLE=${VITE_APP_TITLE}
+    depends_on:
+      - db
+      - api
+    logging:
+      options:
+        max-size: 10m
+
+  web_tests:
+    image: cypress/included
+    container_name: web_tests
+    restart: unless-stopped
+    volumes:
+      - ./frontend/e2e:/e2e
+    links:
+      - "api:postgrest"
+      - "web_dev:frontend"
+    env_file: .env
+    environment:
+      - CYPRESS_BASE_URL=http://web_dev:8080
+    depends_on:
+      - db
+      - api
+      - web_dev
+    logging:
+      options:
+        max-size: 10m
+
+volumes:
+  data: {}

docker-compose.yml

@@ -1,21 +1,25 @@
-version: '3.9'
+version: "3.9"
+
 services:
   db:
     image: xbgmsharp/timescaledb-postgis
     container_name: db
+    hostname: db
     restart: unless-stopped
     env_file: .env
     environment:
-      - POSTGRES_DB=postgres
       - TIMESCALEDB_TELEMETRY=off
       - PGDATA=/var/lib/postgresql/data/pgdata
       - TZ=UTC
-    network_mode: "host"
+      - POSTGRES_USER=${POSTGRES_USER}
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
+      - POSTGRES_DB=${POSTGRES_DB}
+      - PGSAIL_AUTHENTICATOR_PASSWORD=${PGSAIL_AUTHENTICATOR_PASSWORD}
     ports:
       - "5432:5432"
     volumes:
-      - data:/var/lib/postgresql/data
-      - $PWD/initdb:/docker-entrypoint-initdb.d
+      - postgres-data:/var/lib/postgresql/data
+      - ./initdb:/docker-entrypoint-initdb.d
     logging:
       options:
         max-size: 10m
@@ -29,16 +33,25 @@ services:
   api:
     image: postgrest/postgrest
     container_name: api
+    hostname: api
     restart: unless-stopped
+    links:
+      - "db:database"
     ports:
       - "3000:3000"
+      - "3003:3003"
     env_file: .env
     environment:
       PGRST_DB_SCHEMA: api
       PGRST_DB_ANON_ROLE: api_anonymous
       PGRST_OPENAPI_SERVER_PROXY_URI: http://127.0.0.1:3000
       PGRST_DB_PRE_REQUEST: public.check_jwt
-    network_mode: "host"
+      PGRST_DB_POOL: 20
+      PGRST_DB_URI: ${PGRST_DB_URI}
+      PGRST_JWT_SECRET: ${PGRST_JWT_SECRET}
+      PGRST_SERVER_TIMING_ENABLED: 1
+      PGRST_DB_MAX_ROWS: 500
+      PGRST_JWT_CACHE_MAX_LIFETIME: 3600
     depends_on:
       - db
     logging:
@@ -55,16 +68,18 @@ services:
     image: grafana/grafana:latest
     container_name: app
     restart: unless-stopped
+    links:
+      - "db:database"
     volumes:
-      - data:/var/lib/grafana
-      - data:/var/log/grafana
-      - $PWD/grafana:/etc/grafana
+      - grafana-data:/var/lib/grafana
+      - grafana-data:/var/log/grafana
+      - ./grafana:/etc/grafana
     ports:
       - "3001:3000"
-    network_mode: "host"
     env_file: .env
     environment:
       - GF_INSTALL_PLUGINS=pr0ps-trackmap-panel,fatcloud-windrose-panel
+      - GF_SECURITY_ADMIN_PASSWORD=${PGSAIL_GRAFANA_PASSWORD}
       - GF_USERS_ALLOW_SIGN_UP=false
       - GF_SMTP_ENABLED=false
     depends_on:
@@ -83,12 +98,10 @@ services:
     image: xbgmsharp/postgsail-telegram-bot
     container_name: telegram
     restart: unless-stopped
-    volumes:
-      - /etc/resolv.conf:/etc/resolv.conf:ro
+    links:
+      - "api:postgrest"
     ports:
       - "3005:8080"
-    network_mode: "host"
-    env_file: .env
     environment:
       - BOT_TOKEN=${PGSAIL_TELEGRAM_BOT_TOKEN}
       - PGSAIL_URL=${PGSAIL_API_URL}
@@ -100,23 +113,30 @@ services:
         max-size: 10m
 
   web:
-    image: xbgmsharp/vuestic-postgsail:dev
+    image: vuestic-postgsail
     build:
       context: https://github.com/xbgmsharp/vuestic-postgsail.git#live
-      dockerfile: Dockerfile_dev
-    container_name: web_dev
+      dockerfile: Dockerfile
+      args:
+        - VITE_PGSAIL_URL=${PGSAIL_API_URL}
+        - VITE_APP_INCLUDE_DEMOS=false
+        - VITE_APP_BUILD_VERSION=true
+        - VITE_APP_TITLE=${VITE_APP_TITLE}
+        - VITE_GRAFANA_URL=${VITE_GRAFANA_URL}
+    hostname: web
+    container_name: web
     restart: unless-stopped
-    volumes:
-      - /etc/resolv.conf:/etc/resolv.conf:ro
+    links:
+      - "api:postgrest"
     ports:
-      - "3006:8080"
-    network_mode: "host"
+      - 8080:8080
     env_file: .env
     environment:
       - VITE_PGSAIL_URL=${PGSAIL_API_URL}
-      - VUE_APP_INCLUDE_DEMOS=false
+      - VITE_APP_INCLUDE_DEMOS=false
       - VITE_APP_BUILD_VERSION=true
-      - VITE_APP_TITLE=PostgSail Dev
+      - VITE_APP_TITLE=${VITE_APP_TITLE}
+      - VITE_GRAFANA_URL=${VITE_GRAFANA_URL}
     depends_on:
       - db
       - api
@@ -125,4 +145,5 @@ services:
         max-size: 10m
 
 volumes:
-  data: {}
+  grafana-data: {}
+  postgres-data: {}

docs/ERD/README.md

@@ -0,0 +1,124 @@
+# PostgSail ERD
+The Entity-Relationship Diagram (ERD) provides a graphical representation of database tables, columns, and inter-relationships. ERD can give sufficient information for the database administrator to follow when developing and maintaining the database.
+
+## A global overview
+Auto generated Mermaid diagram using [mermerd](https://github.com/KarnerTh/mermerd) and [MermaidJs](https://github.com/mermaid-js/mermaid).
+
+[PostgSail SQL Schema](https://github.com/xbgmsharp/postgsail/tree/main/docs/ERD/postgsail.md "PostgSail SQL Schema")
+
+## Further
+There is 3 main schemas into the signalk database:
+- API Schema:
+  - tables
+    - metrics
+    - logbook
+    - ...
+  - functions
+    - ...
+
+- Auth Schema:
+  - tables
+    - accounts
+    - vessels
+    - ...
+  - functions
+    - ...
+
+- Public Schema:
+  - tables
+    - app_settings
+    - tpl_messages
+    - ...
+  - functions
+    - ...
+
+## Overview
+- Insert data into table metadata from API using PostgREST
+- Insert data into table metrics from API using PostgREST
+- TimescaleDB Hypertable to store signalk metrics
+- pgsql functions to generate logbook, stays, moorages
+- CRON functions to process logbook, stays, moorages
+- python functions for geo reverse and send notification via email and/or pushover
+- Views statistics, timelapse, monitoring, logs
+- Always store time in UTC
+
+## Ingest flowchart
+```mermaid
+graph LR
+    A[SignalK] -- HTTP POST --> B{PostgREST}
+    B -- SQL --> C{PostgreSQL}
+    C --> D((metadata trigger))
+    C --> E((metrics trigger))
+    D --> F{tbl.metadata}
+    E --> G{tbl.metrics}
+    E --> H{tbl.logs}
+    E --> I{tbl.stays}
+```
+
+## pg_cron flowchart
+```mermaid
+flowchart TD
+    A[pg_cron] --> B((cron_new_notification))
+    A --> C((cron_pre_logbook))
+    A --> D((cron_new_logbook))
+    A --> E((cron_new_stay))
+    A --> F((cron_monitor_offline))
+    A --> G((cron_monitor_online))
+    C --> K{Validate logbook details}
+    D --> L{Update logbook details}
+    E --> M{Update stay details}
+    L --> N{Update Moorages details}
+    M --> N{Update Moorages details}
+    B --> O{Update account,vessel,otp}
+    F --> P{Update metadata}
+    G --> P
+    A --> Q((cron_post_logbook))
+    Q --> R{QGIS and notification}
+```
+cron job are not process by default because if you don't have the correct settings set (SMTP, PushOver, Telegram), you might enter in a loop with error and you could be blocked or banned from the external services.
+
+Therefor by default they are no active job as it require external configuration settings (SMTP, PushOver, Telegram).
+To activate all cron.job run the following SQL command:
+```sql
+UPDATE cron.job SET active = True;
+```
+Be sure to review your postgsail settings via SQL in the table `app_settings`:
+```sql
+SELECT * FROM public.app_settings;
+```
+
+### How to bypass OTP for a local install?
+
+To can skip the otp process, add or update the following json key value to the account preference.
+```json
+"email_valid": true
+```
+SQL query
+```sql
+UPDATE auth.accounts
+	SET preferences='{"email_valid": true}'::jsonb || preferences
+	WHERE email='your.email@domain.com';
+```
+
+OTP is created and sent by email using a cron in postgres/cron/job.
+```sql
+SELECT * FROM auth.otp;
+```
+
+Accounts are store in table signalk/auth/accounts
+```sql
+SELECT * FROM auth.accounts;
+```
+
+You should have an history in table signalk/public/process_queue
+```sql
+SELECT * from public.process_queue;
+```
+
+### How to turn off signups
+
+If you just want to use this as a standalone application and don't want people to be able to sign up for an account.
+
+```SQL
+revoke execute on function api.signup(text,text,text,text) to api_anonymous;
+```

docs/ERD/mermerdConfig.yaml

@@ -0,0 +1,35 @@
+# Connection properties
+connectionString: ${PGSAIL_DB_URI}
+
+# Define what schemas should be used
+#useAllSchemas: true
+# or
+schema:
+  - "public"
+  - "api"
+  - "auth"
+
+# Define what tables should be used
+useAllTables: true
+# or
+#selectedTables:
+#  - city
+#  - customer
+
+# Additional flags
+showAllConstraints: true
+encloseWithMermaidBackticks: true
+outputFileName: "postgsail.md"
+debug: true
+omitConstraintLabels: true
+omitAttributeKeys: true
+showDescriptions:
+  - enumValues
+  - columnComments
+  - notNull
+showSchemaPrefix: true
+schemaPrefixSeparator: "_"
+
+# Names must match the pattern <schema><schema_prefix><table>
+#relationshipLabels:
+#  - "public_table public_another-table : label"

docs/ERD/postgsail.md

@@ -0,0 +1,261 @@
+```mermaid
+erDiagram
+    api_logbook {
+        text _from 
+        double_precision _from_lat 
+        double_precision _from_lng 
+        integer _from_moorage_id "Link api.moorages with api.logbook via FOREIGN KEY and REFERENCES"
+        timestamp_with_time_zone _from_time "{NOT_NULL}"
+        text _to 
+        double_precision _to_lat 
+        double_precision _to_lng 
+        integer _to_moorage_id "Link api.moorages with api.logbook via FOREIGN KEY and REFERENCES"
+        timestamp_with_time_zone _to_time 
+        boolean active 
+        double_precision avg_speed 
+        numeric distance "in NM"
+        interval duration "Best to use standard ISO 8601"
+        jsonb extra "computed signalk metrics of interest, runTime, currentLevel, etc"
+        integer id "{NOT_NULL}"
+        double_precision max_speed 
+        double_precision max_wind_speed 
+        text name 
+        text notes 
+        geography track_geog "postgis geography type default SRID 4326 Unit: degres"
+        jsonb track_geojson "store generated geojson with track metrics data using with LineString and Point features, we can not depend api.metrics table"
+        geometry track_geom "postgis geometry type EPSG:4326 Unit: degres"
+        text vessel_id "{NOT_NULL}"
+    }
+
+    api_metadata {
+        boolean active "trigger monitor online/offline"
+        boolean active 
+        double_precision beam 
+        text client_id 
+        text configuration 
+        timestamp_with_time_zone created_at "{NOT_NULL}"
+        double_precision height 
+        integer id "{NOT_NULL}"
+        double_precision length 
+        numeric mmsi 
+        text name 
+        text platform 
+        text plugin_version "{NOT_NULL}"
+        numeric ship_type 
+        text signalk_version "{NOT_NULL}"
+        timestamp_with_time_zone time "{NOT_NULL}"
+        timestamp_with_time_zone updated_at "{NOT_NULL}"
+        text vessel_id "Link auth.vessels with api.metadata via FOREIGN KEY and REFERENCES {NOT_NULL}"
+        text vessel_id "{NOT_NULL}"
+    }
+
+    api_metrics {
+        double_precision anglespeedapparent 
+        text client_id 
+        double_precision courseovergroundtrue 
+        double_precision latitude "With CONSTRAINT but allow NULL value to be ignored silently by trigger"
+        double_precision longitude "With CONSTRAINT but allow NULL value to be ignored silently by trigger"
+        jsonb metrics 
+        double_precision speedoverground 
+        text status 
+        timestamp_with_time_zone time "{NOT_NULL}"
+        text vessel_id "{NOT_NULL}"
+        double_precision windspeedapparent 
+    }
+
+    api_moorages {
+        text country 
+        geography geog "postgis geography type default SRID 4326 Unit: degres"
+        boolean home_flag 
+        integer id "{NOT_NULL}"
+        double_precision latitude 
+        double_precision longitude 
+        text name 
+        jsonb nominatim 
+        text notes 
+        jsonb overpass 
+        integer reference_count 
+        integer stay_code "Link api.stays_at with api.moorages via FOREIGN KEY and REFERENCES"
+        interval stay_duration "Best to use standard ISO 8601"
+        text vessel_id "{NOT_NULL}"
+    }
+
+    api_stays {
+        boolean active 
+        timestamp_with_time_zone arrived "{NOT_NULL}"
+        timestamp_with_time_zone departed 
+        interval duration "Best to use standard ISO 8601"
+        geography geog "postgis geography type default SRID 4326 Unit: degres"
+        integer id "{NOT_NULL}"
+        double_precision latitude 
+        double_precision longitude 
+        integer moorage_id "Link api.moorages with api.stays via FOREIGN KEY and REFERENCES"
+        text name 
+        text notes 
+        integer stay_code "Link api.stays_at with api.stays via FOREIGN KEY and REFERENCES"
+        text vessel_id "{NOT_NULL}"
+    }
+
+    api_stays_at {
+        text description "{NOT_NULL}"
+        integer stay_code "{NOT_NULL}"
+    }
+
+    auth_accounts {
+        timestamp_with_time_zone connected_at "{NOT_NULL}"
+        timestamp_with_time_zone created_at "{NOT_NULL}"
+        citext email "{NOT_NULL}"
+        text first "User first name with CONSTRAINT CHECK {NOT_NULL}"
+        integer id "{NOT_NULL}"
+        text last "User last name with CONSTRAINT CHECK {NOT_NULL}"
+        text pass "{NOT_NULL}"
+        jsonb preferences 
+        name role "{NOT_NULL}"
+        timestamp_with_time_zone updated_at "{NOT_NULL}"
+        text user_id "{NOT_NULL}"
+    }
+
+    auth_otp {
+        text otp_pass "{NOT_NULL}"
+        timestamp_with_time_zone otp_timestamp 
+        smallint otp_tries "{NOT_NULL}"
+        citext user_email "{NOT_NULL}"
+    }
+
+    auth_users {
+        timestamp_with_time_zone connected_at "{NOT_NULL}"
+        timestamp_with_time_zone created_at "{NOT_NULL}"
+        name email "{NOT_NULL}"
+        text first "{NOT_NULL}"
+        name id "{NOT_NULL}"
+        text last "{NOT_NULL}"
+        jsonb preferences 
+        name role "{NOT_NULL}"
+        timestamp_with_time_zone updated_at "{NOT_NULL}"
+        text user_id "{NOT_NULL}"
+    }
+
+    auth_vessels {
+        timestamp_with_time_zone created_at "{NOT_NULL}"
+        numeric mmsi "MMSI can be optional but if present must be a valid one and unique but must be in numeric range between 100000000 and 800000000"
+        text name "{NOT_NULL}"
+        citext owner_email "{NOT_NULL}"
+        name role "{NOT_NULL}"
+        timestamp_with_time_zone updated_at "{NOT_NULL}"
+        text vessel_id "{NOT_NULL}"
+    }
+
+    public_aistypes {
+        text description 
+        numeric id 
+    }
+
+    public_app_settings {
+        text name "application settings name key {NOT_NULL}"
+        text value "application settings value {NOT_NULL}"
+    }
+
+    public_badges {
+        text description 
+        text name 
+    }
+
+    public_email_templates {
+        text email_content 
+        text email_subject 
+        text name 
+        text pushover_message 
+        text pushover_title 
+    }
+
+    public_geocoders {
+        text name 
+        text reverse_url 
+        text url 
+    }
+
+    public_iso3166 {
+        text alpha_2 
+        text alpha_3 
+        text country 
+        integer id 
+    }
+
+    public_mid {
+        text country 
+        integer country_id 
+        numeric id 
+    }
+
+    public_ne_10m_geography_marine_polys {
+        text changed 
+        text featurecla 
+        geometry geom 
+        integer gid "{NOT_NULL}"
+        text label 
+        double_precision max_label 
+        double_precision min_label 
+        text name 
+        text name_ar 
+        text name_bn 
+        text name_de 
+        text name_el 
+        text name_en 
+        text name_es 
+        text name_fa 
+        text name_fr 
+        text name_he 
+        text name_hi 
+        text name_hu 
+        text name_id 
+        text name_it 
+        text name_ja 
+        text name_ko 
+        text name_nl 
+        text name_pl 
+        text name_pt 
+        text name_ru 
+        text name_sv 
+        text name_tr 
+        text name_uk 
+        text name_ur 
+        text name_vi 
+        text name_zh 
+        text name_zht 
+        text namealt 
+        bigint ne_id 
+        text note 
+        smallint scalerank 
+        text wikidataid 
+    }
+
+    public_process_queue {
+        text channel "{NOT_NULL}"
+        integer id "{NOT_NULL}"
+        text payload "{NOT_NULL}"
+        timestamp_with_time_zone processed 
+        text ref_id "either user_id or vessel_id {NOT_NULL}"
+        timestamp_with_time_zone stored "{NOT_NULL}"
+    }
+
+    public_spatial_ref_sys {
+        character_varying auth_name 
+        integer auth_srid 
+        character_varying proj4text 
+        integer srid "{NOT_NULL}"
+        character_varying srtext 
+    }
+
+    api_logbook }o--|| api_metadata : ""
+    api_logbook }o--|| api_moorages : ""
+    api_logbook }o--|| api_moorages : ""
+    api_metadata }o--|| auth_vessels : ""
+    api_metrics }o--|| api_metadata : ""
+    api_moorages }o--|| api_metadata : ""
+    api_stays }o--|| api_metadata : ""
+    api_moorages }o--|| api_stays_at : ""
+    api_stays }o--|| api_moorages : ""
+    api_stays }o--|| api_stays_at : ""
+    auth_otp |o--|| auth_accounts : ""
+    auth_vessels |o--|| auth_accounts : ""
+```

docs/README.md

@@ -0,0 +1,206 @@
+
+
+## Architecture
+
+Efficient, simple and scalable architecture.
+
+![Architecture overview](https://raw.githubusercontent.com/xbgmsharp/postgsail/main/PostgSail.png "Architecture overview")
+
+
+For more clarity and visibility the complete [Entity-Relationship Diagram (ERD)](https://github.com/xbgmsharp/postgsail/blob/main/docs/ERD/README.md) is export as Mermaid, PNG and SVG file.
+
+## Using PostgSail
+### Development
+
+A full-featured development environment.
+
+#### With CodeSandbox
+
+- Develop on [![CodeSandbox Ready-to-Code](https://img.shields.io/badge/CodeSandbox-Ready--to--Code-blue?logo=codesandbox)](https://codesandbox.io/p/github/xbgmsharp/postgsail/main)
+  - or via [direct link](https://codesandbox.io/p/github/xbgmsharp/postgsail/main)
+
+#### With DevPod
+
+- [![Open in DevPod!](https://devpod.sh/assets/open-in-devpod.svg)](https://devpod.sh/open#https://github.com/xbgmsharp/postgsail/&workspace=postgsail&provider=docker&ide=openvscode)
+  - or via [direct link](https://devpod.sh/open#https://github.com/xbgmsharp/postgsail&workspace=postgsail&provider=docker&ide=openvscode)
+
+#### With Docker Dev Environments
+- [Open in Docker dev-envs!](https://open.docker.com/dashboard/dev-envs?url=https://github.com/xbgmsharp/postgsail/)
+
+
+### On-premise (self-hosted)
+
+This kind of deployment needs the [docker application](https://www.docker.com/) to be installed and running. Check this [tutorial](https://www.docker.com/101-tutorial).
+
+Docker run pre packaged application (aka images) which can be retrieved as sources (Dockerfile and resources) to build or already built from registries (private or public).
+
+PostgSail depends heavily on [PostgreSQL](https://www.postgresql.org/). Check this [tutorial](https://www.postgresql.org/docs/current/tutorial.html).
+
+#### pre-deploy configuration
+
+To get these running, copy `.env.example` and rename to `.env` then set the value accordingly.
+
+```bash
+# cp .env.example .env
+```
+
+```bash
+# nano .env
+```
+
+Notice, that `PGRST_JWT_SECRET` must be at least 32 characters long.
+
+`$ cat /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' | fold -w 42 | head -n 1`
+
+`PGSAIL_APP_URL` is the URL you connect to from your browser.
+
+`PGSAIL_API_URL` is the URL where `PGSAIL_APP_URL` connect to.
+
+`PGRST_DB_URI` is the URI where the `PGSAIL_API_URL` connect to.
+
+To summarize:
+```mermaid
+flowchart LR
+    subgraph frontend
+        direction TB
+        A(PGSAIL_APP_URL)
+        B(PGSAIL_API_URL)
+    end
+    subgraph backend
+        direction TB
+        B(PGSAIL_API_URL) -- SQL --> C(PGRST_DB_URI)
+    end
+    %% ^ These subgraphs are identical, except for the links to them:
+
+    %% Link *to* subgraph1: subgraph1 direction is maintained
+
+    User -- HTTP --> A
+    User -- HTTP --> B
+    %% Link *within* subgraph2:
+    %% subgraph2 inherits the direction of the top-level graph (LR)
+
+    Boat -- HTTP --> B
+```
+
+### Deploy
+
+There is two compose files used. You can update the default settings by editing `docker-compose.yml` and `docker-compose.dev.yml` to your need.
+
+Now let's initialize the database.
+
+#### Step 1. Initialize database
+
+First let's import the SQL schema, execute:
+
+```bash
+$ docker compose up db
+```
+
+#### Step 2. Start backend (db, api)
+
+Then launch the full backend stack (db, api), execute:
+
+```bash
+$ docker compose up db api
+```
+
+The API should be accessible via port HTTP/3000.
+The database should be accessible via port TCP/5432.
+
+You can connect to the database via a web gui like [pgadmin](https://www.pgadmin.org/) or you can use a client [dbeaver](https://dbeaver.io/).
+```bash
+$ docker compose -f docker-compose.yml -f docker-compose.dev.yml pgadmin
+```
+Then connect to the web UI on port HTTP/5050.
+
+#### Step 3. Start frontend (web)
+
+Then launch the web frontend, execute:
+
+```bash
+$ docker compose up web
+```
+This step can take some time as it will first do a build to generate the static website based on your settings.
+
+The frontend should be accessible via port HTTP/8080.
+
+Users are collaborating on an installation guide, [Self-hosted-installation-guide](https://github.com/xbgmsharp/postgsail/wiki/Self-hosted-installation-guide)
+
+### SQL Configuration
+
+Check and update your postgsail settings via SQL in the table `app_settings`:
+
+```sql
+SELECT * FROM app_settings;
+```
+
+```sql
+UPDATE app_settings
+    SET
+        value = 'new_value'
+    WHERE name = 'app.email_server';
+```
+
+As it is all about SQL, [Read more](https://github.com/xbgmsharp/postgsail/blob/main/docs/ERD/README.md) about the database to configure your instance and explore your data.
+
+### Ingest data
+
+Next, to ingest data from signalk, you need to install [signalk-postgsail](https://github.com/xbgmsharp/signalk-postgsail) plugin on your signalk server instance.
+
+Also, if you like, you can import saillogger data using the postgsail helpers, [postgsail-helpers](https://github.com/xbgmsharp/postgsail-helpers).
+
+You might want to import your influxdb1 data as well, [outflux](https://github.com/timescale/outflux).
+For InfluxDB 2.x and 3.x. You will need to enable the 1.x APIs to use them. Consult the InfluxDB documentation for more details.
+
+Last, if you like, you can import the sample data from Signalk NMEA Plaka by running the tests.
+If everything goes well all tests pass successfully and you should receive a few notifications by email or PushOver or Telegram.
+[End-to-End (E2E) Testing.](https://github.com/xbgmsharp/postgsail/blob/main/tests/)
+
+```
+$ docker-compose up tests
+```
+
+### API Documentation
+
+The OpenAPI description output depends on the permissions of the role that is contained in the JWT role claim.
+
+Other applications can also use the [PostgSAIL API](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/xbgmsharp/postgsail/main/openapi.json).
+
+API anonymous:
+
+```
+$ curl http://localhost:3000/
+```
+
+API user_role:
+
+```
+$ curl http://localhost:3000/ -H 'Authorization: Bearer my_token_from_login_or_signup_fn'
+```
+
+API vessel_role:
+
+```
+$ curl http://localhost:3000/ -H 'Authorization: Bearer my_token_from_register_vessel_fn'
+```
+
+#### API main workflow
+
+Check the [End-to-End (E2E) test sample](https://github.com/xbgmsharp/postgsail/blob/main/tests/).
+
+### Docker dependencies
+
+`docker-compose` is used to start environment dependencies. Dependencies consist of 3 containers:
+
+- `timescaledb-postgis` alias `db`, PostgreSQL with TimescaleDB extension along with the PostGIS extension.
+- `postgrest` alias `api`, Standalone web server that turns your PostgreSQL database directly into a RESTful API.
+- `grafana` alias `app`, visualize and monitor your data
+
+### Optional docker images
+
+- [pgAdmin](https://hub.docker.com/r/dpage/pgadmin4), web UI to monitor and manage multiple PostgreSQL
+- [Swagger](https://hub.docker.com/r/swaggerapi/swagger-ui), web UI to visualize documentation from PostgREST
+
+```
+docker-compose -f docker-compose-optional.yml up
+```

grafana/dashboards/home.json

@@ -1,134 +0,0 @@
-{
-    "annotations": {
-      "list": [
-        {
-          "builtIn": 1,
-          "datasource": {
-            "type": "grafana",
-            "uid": "-- Grafana --"
-          },
-          "enable": true,
-          "hide": true,
-          "iconColor": "rgba(0, 211, 255, 1)",
-          "name": "Annotations & Alerts",
-          "target": {
-            "limit": 100,
-            "matchAny": false,
-            "tags": [],
-            "type": "dashboard"
-          },
-          "type": "dashboard"
-        }
-      ]
-    },
-    "editable": true,
-    "fiscalYearStartMonth": 0,
-    "graphTooltip": 0,
-    "links": [],
-    "liveNow": false,
-    "panels": [
-      {
-        "datasource": {
-          "type": "postgres",
-          "uid": "OIttR1sVk"
-        },
-        "gridPos": {
-          "h": 3,
-          "w": 24,
-          "x": 0,
-          "y": 0
-        },
-        "id": 1,
-        "targets": [
-          {
-            "datasource": {
-              "type": "postgres",
-              "uid": "OIttR1sVk"
-            },
-            "refId": "A"
-          }
-        ],
-        "type": "welcome"
-      },
-      {
-        "datasource": {
-          "type": "postgres",
-          "uid": "OIttR1sVk"
-        },
-        "gridPos": {
-          "h": 12,
-          "w": 24,
-          "x": 0,
-          "y": 3
-        },
-        "id": 3,
-        "links": [],
-        "options": {
-          "folderId": 0,
-          "maxItems": 30,
-          "query": "",
-          "showHeadings": true,
-          "showRecentlyViewed": true,
-          "showSearch": false,
-          "showStarred": true,
-          "tags": []
-        },
-        "pluginVersion": "9.4.3",
-        "tags": [],
-        "targets": [
-          {
-            "datasource": {
-              "type": "postgres",
-              "uid": "OIttR1sVk"
-            },
-            "refId": "A"
-          }
-        ],
-        "title": "Dashboards",
-        "type": "dashlist"
-      }
-    ],
-    "refresh": "",
-    "revision": 1,
-    "schemaVersion": 38,
-    "style": "dark",
-    "tags": [],
-    "templating": {
-      "list": []
-    },
-    "time": {
-      "from": "now-6h",
-      "to": "now"
-    },
-    "timepicker": {
-      "hidden": true,
-      "refresh_intervals": [
-        "5s",
-        "10s",
-        "30s",
-        "1m",
-        "5m",
-        "15m",
-        "30m",
-        "1h",
-        "2h",
-        "1d"
-      ],
-      "time_options": [
-        "5m",
-        "15m",
-        "1h",
-        "6h",
-        "12h",
-        "24h",
-        "2d",
-        "7d",
-        "30d"
-      ],
-      "type": "timepicker"
-    },
-    "timezone": "browser",
-    "title": "Home",
-    "version": 0,
-    "weekStart": ""
-  }

grafana/dashboards/tpl/Electrical.json

@@ -20,8 +20,21 @@
   "editable": true,
   "fiscalYearStartMonth": 0,
   "graphTooltip": 0,
-  "id": 6,
-  "links": [],
+  "id": 1,
+  "links": [
+    {
+      "asDropdown": false,
+      "icon": "external link",
+      "includeVars": true,
+      "keepTime": false,
+      "tags": [],
+      "targetBlank": true,
+      "title": "New link",
+      "tooltip": "",
+      "type": "dashboards",
+      "url": ""
+    }
+  ],
   "liveNow": false,
   "panels": [
     {
@@ -83,7 +96,7 @@
         "showThresholdLabels": false,
         "showThresholdMarkers": true
       },
-      "pluginVersion": "9.5.1",
+      "pluginVersion": "10.1.0",
       "targets": [
         {
           "datasource": {
@@ -220,7 +233,7 @@
         },
         "textMode": "auto"
       },
-      "pluginVersion": "9.5.1",
+      "pluginVersion": "10.1.0",
       "targets": [
         {
           "datasource": {
@@ -346,7 +359,7 @@
         },
         "textMode": "auto"
       },
-      "pluginVersion": "9.5.1",
+      "pluginVersion": "10.1.0",
       "targets": [
         {
           "datasource": {
@@ -481,7 +494,7 @@
         },
         "textMode": "auto"
       },
-      "pluginVersion": "9.5.1",
+      "pluginVersion": "10.1.0",
       "targets": [
         {
           "datasource": {
@@ -591,7 +604,7 @@
         },
         "textMode": "auto"
       },
-      "pluginVersion": "9.5.1",
+      "pluginVersion": "10.1.0",
       "targets": [
         {
           "datasource": {
@@ -719,7 +732,7 @@
         },
         "textMode": "auto"
       },
-      "pluginVersion": "9.5.1",
+      "pluginVersion": "10.1.0",
       "targets": [
         {
           "datasource": {
@@ -766,50 +779,108 @@
       "type": "stat"
     },
     {
-      "aliasColors": {
-        "electrical.batteries.256.current.mean": "blue"
-      },
-      "bars": false,
-      "dashLength": 10,
-      "dashes": false,
       "datasource": {
         "type": "postgres",
         "uid": "PCC52D03280B7034C"
       },
-      "fill": 1,
-      "fillGradient": 0,
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "insertNulls": false,
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "line+area"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "transparent",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": -1
+              },
+              {
+                "color": "red",
+                "value": 1
+              }
+            ]
+          },
+          "unit": "amp"
+        },
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "electrical.batteries.256.current.mean"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "blue",
+                  "mode": "fixed"
+                }
+              }
+            ]
+          }
+        ]
+      },
       "gridPos": {
         "h": 8,
         "w": 12,
         "x": 0,
         "y": 5
       },
-      "hiddenSeries": false,
       "id": 47,
-      "legend": {
-        "avg": true,
-        "current": false,
-        "max": true,
-        "min": true,
-        "show": true,
-        "total": false,
-        "values": true
-      },
-      "lines": true,
-      "linewidth": 1,
-      "nullPointMode": "null",
       "options": {
-        "alertThreshold": true
+        "legend": {
+          "calcs": [
+            "mean",
+            "max",
+            "min"
+          ],
+          "displayMode": "list",
+          "placement": "bottom",
+          "showLegend": true
         },
-      "percentage": false,
-      "pluginVersion": "9.5.1",
-      "pointradius": 2,
-      "points": false,
-      "renderer": "flot",
-      "seriesOverrides": [],
-      "spaceLength": 10,
-      "stack": false,
-      "steppedLine": false,
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "pluginVersion": "10.1.0",
       "targets": [
         {
           "datasource": {
@@ -835,7 +906,8 @@
           "measurement": "electrical.batteries.256.current",
           "orderByTime": "ASC",
           "policy": "default",
-          "rawSql": "",
+          "rawQuery": true,
+          "rawSql": "SET vessel.id = '${__user.login}';\nSELECT m.time, cast(m.metrics->'electrical.batteries.House.current' as NUMERIC) as current FROM api.metrics m WHERE $__timeFilter(time) AND m.vessel_id = '${boat}';\n",
           "refId": "A",
           "resultFormat": "time_series",
           "select": [
@@ -872,56 +944,379 @@
           "tags": []
         }
       ],
-      "thresholds": [
-        {
-          "$$hashKey": "object:8288",
-          "colorMode": "critical",
-          "fill": true,
-          "line": true,
-          "op": "gt",
-          "value": -1,
-          "yaxis": "left"
-        },
-        {
-          "$$hashKey": "object:8294",
-          "colorMode": "ok",
-          "fill": true,
-          "line": true,
-          "op": "gt",
-          "value": 1,
-          "yaxis": "left"
-        }
-      ],
-      "timeRegions": [],
       "title": "House Amps",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "postgres",
+        "uid": "PCC52D03280B7034C"
+      },
+      "description": "",
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "insertNulls": false,
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 10,
+        "x": 12,
+        "y": 5
+      },
+      "id": 48,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom",
+          "showLegend": true
+        },
         "tooltip": {
-        "shared": true,
-        "sort": 0,
-        "value_type": "individual"
+          "mode": "single",
+          "sort": "none"
+        }
       },
-      "type": "graph",
-      "xaxis": {
-        "mode": "time",
-        "show": true,
-        "values": []
-      },
-      "yaxes": [
+      "targets": [
         {
-          "$$hashKey": "object:8148",
-          "format": "amp",
-          "logBase": 1,
-          "show": true
+          "datasource": {
+            "type": "postgres",
+            "uid": "PCC52D03280B7034C"
           },
+          "editorMode": "code",
+          "format": "table",
+          "rawQuery": true,
+          "rawSql": "SET vessel.id = '${__user.login}';\nSELECT m.time, cast(m.metrics->'electrical.batteries.House.capacity.stateOfCharge' as NUMERIC) * 100 as stateOfCharge FROM api.metrics m WHERE $__timeFilter(time) AND m.vessel_id = '${boat}';\n",
+          "refId": "A",
+          "sql": {
+            "columns": [
               {
-          "$$hashKey": "object:8149",
-          "format": "short",
-          "logBase": 1,
-          "show": true
+                "parameters": [],
+                "type": "function"
               }
             ],
-      "yaxis": {
-        "align": false
+            "groupBy": [
+              {
+                "property": {
+                  "type": "string"
+                },
+                "type": "groupBy"
               }
+            ],
+            "limit": 50
+          }
+        }
+      ],
+      "title": "System - Battery SOC (State of Charge)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "postgres",
+        "uid": "PCC52D03280B7034C"
+      },
+      "description": "",
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "Volts",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "insertNulls": false,
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          },
+          "unit": "volt"
+        },
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "current"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "blue",
+                  "mode": "fixed"
+                }
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "voltage"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "yellow",
+                  "mode": "fixed"
+                }
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "current"
+            },
+            "properties": [
+              {
+                "id": "unit",
+                "value": "amp"
+              },
+              {
+                "id": "custom.axisLabel",
+                "value": "Amps"
+              }
+            ]
+          }
+        ]
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 13
+      },
+      "id": 37,
+      "options": {
+        "legend": {
+          "calcs": [
+            "mean",
+            "max",
+            "min"
+          ],
+          "displayMode": "list",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "pluginVersion": "10.1.0",
+      "targets": [
+        {
+          "datasource": {
+            "type": "postgres",
+            "uid": "PCC52D03280B7034C"
+          },
+          "editorMode": "code",
+          "format": "table",
+          "groupBy": [
+            {
+              "params": [
+                "$__interval"
+              ],
+              "type": "time"
+            },
+            {
+              "params": [
+                "null"
+              ],
+              "type": "fill"
+            }
+          ],
+          "measurement": "electrical.batteries.256.voltage",
+          "orderByTime": "ASC",
+          "policy": "default",
+          "rawQuery": true,
+          "rawSql": "SET vessel.id = '${__user.login}';\nSELECT m.time, cast(m.metrics->'electrical.batteries.House.voltage' as NUMERIC) as voltage FROM api.metrics m WHERE $__timeFilter(time) AND m.vessel_id = '${boat}';\n",
+          "refId": "A",
+          "resultFormat": "time_series",
+          "select": [
+            [
+              {
+                "params": [
+                  "value"
+                ],
+                "type": "field"
+              },
+              {
+                "params": [],
+                "type": "mean"
+              }
+            ]
+          ],
+          "sql": {
+            "columns": [
+              {
+                "parameters": [],
+                "type": "function"
+              }
+            ],
+            "groupBy": [
+              {
+                "property": {
+                  "type": "string"
+                },
+                "type": "groupBy"
+              }
+            ],
+            "limit": 50
+          },
+          "tags": []
+        },
+        {
+          "datasource": {
+            "type": "postgres",
+            "uid": "PCC52D03280B7034C"
+          },
+          "editorMode": "code",
+          "format": "table",
+          "groupBy": [
+            {
+              "params": [
+                "$__interval"
+              ],
+              "type": "time"
+            },
+            {
+              "params": [
+                "null"
+              ],
+              "type": "fill"
+            }
+          ],
+          "hide": false,
+          "measurement": "electrical.batteries.256.current",
+          "orderByTime": "ASC",
+          "policy": "default",
+          "query": "SELECT mean(\"value\") FROM \"electrical.batteries.256.current\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+          "rawQuery": true,
+          "rawSql": "SET vessel.id = '${__user.login}';\nSELECT m.time, cast(m.metrics->'electrical.batteries.House.current' as NUMERIC) as current FROM api.metrics m WHERE $__timeFilter(time) AND m.vessel_id = '${boat}';\n",
+          "refId": "B",
+          "resultFormat": "time_series",
+          "select": [
+            [
+              {
+                "params": [
+                  "value"
+                ],
+                "type": "field"
+              },
+              {
+                "params": [],
+                "type": "mean"
+              }
+            ]
+          ],
+          "sql": {
+            "columns": [
+              {
+                "parameters": [],
+                "type": "function"
+              }
+            ],
+            "groupBy": [
+              {
+                "property": {
+                  "type": "string"
+                },
+                "type": "groupBy"
+              }
+            ],
+            "limit": 50
+          },
+          "tags": []
+        }
+      ],
+      "title": "Battery Voltage and Current",
+      "type": "timeseries"
     },
     {
       "aliasColors": {
@@ -938,9 +1333,9 @@
       "fillGradient": 0,
       "gridPos": {
         "h": 8,
-        "w": 12,
+        "w": 10,
         "x": 12,
-        "y": 5
+        "y": 13
       },
       "hiddenSeries": false,
       "id": 45,
@@ -960,7 +1355,7 @@
         "alertThreshold": true
       },
       "percentage": false,
-      "pluginVersion": "9.5.1",
+      "pluginVersion": "10.1.0",
       "pointradius": 2,
       "points": false,
       "renderer": "flot",
@@ -1042,180 +1437,6 @@
         "align": false
       }
     },
-    {
-      "aliasColors": {
-        "electrical.batteries.256.current.mean": "blue",
-        "electrical.batteries.256.voltage.mean": "yellow"
-      },
-      "bars": false,
-      "dashLength": 10,
-      "dashes": false,
-      "datasource": {
-        "type": "postgres",
-        "uid": "PCC52D03280B7034C"
-      },
-      "description": "",
-      "fill": 1,
-      "fillGradient": 0,
-      "gridPos": {
-        "h": 8,
-        "w": 12,
-        "x": 0,
-        "y": 13
-      },
-      "hiddenSeries": false,
-      "id": 37,
-      "legend": {
-        "alignAsTable": false,
-        "avg": true,
-        "current": false,
-        "max": true,
-        "min": true,
-        "rightSide": false,
-        "show": true,
-        "total": false,
-        "values": true
-      },
-      "lines": true,
-      "linewidth": 1,
-      "nullPointMode": "null",
-      "options": {
-        "alertThreshold": true
-      },
-      "percentage": false,
-      "pluginVersion": "9.5.1",
-      "pointradius": 2,
-      "points": false,
-      "renderer": "flot",
-      "seriesOverrides": [
-        {
-          "$$hashKey": "object:5017",
-          "alias": "electrical.batteries.256.current.mean",
-          "yaxis": 2
-        }
-      ],
-      "spaceLength": 10,
-      "stack": false,
-      "steppedLine": false,
-      "targets": [
-        {
-          "datasource": {
-            "type": "postgres",
-            "uid": "PCC52D03280B7034C"
-          },
-          "groupBy": [
-            {
-              "params": [
-                "$__interval"
-              ],
-              "type": "time"
-            },
-            {
-              "params": [
-                "null"
-              ],
-              "type": "fill"
-            }
-          ],
-          "measurement": "electrical.batteries.256.voltage",
-          "orderByTime": "ASC",
-          "policy": "default",
-          "refId": "A",
-          "resultFormat": "time_series",
-          "select": [
-            [
-              {
-                "params": [
-                  "value"
-                ],
-                "type": "field"
-              },
-              {
-                "params": [],
-                "type": "mean"
-              }
-            ]
-          ],
-          "tags": []
-        },
-        {
-          "datasource": {
-            "type": "postgres",
-            "uid": "PCC52D03280B7034C"
-          },
-          "groupBy": [
-            {
-              "params": [
-                "$__interval"
-              ],
-              "type": "time"
-            },
-            {
-              "params": [
-                "null"
-              ],
-              "type": "fill"
-            }
-          ],
-          "hide": false,
-          "measurement": "electrical.batteries.256.current",
-          "orderByTime": "ASC",
-          "policy": "default",
-          "query": "SELECT mean(\"value\") FROM \"electrical.batteries.256.current\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
-          "rawQuery": true,
-          "refId": "B",
-          "resultFormat": "time_series",
-          "select": [
-            [
-              {
-                "params": [
-                  "value"
-                ],
-                "type": "field"
-              },
-              {
-                "params": [],
-                "type": "mean"
-              }
-            ]
-          ],
-          "tags": []
-        }
-      ],
-      "thresholds": [],
-      "timeRegions": [],
-      "title": "House Bank Voltage vs Current",
-      "tooltip": {
-        "shared": true,
-        "sort": 0,
-        "value_type": "individual"
-      },
-      "type": "graph",
-      "xaxis": {
-        "mode": "time",
-        "show": true,
-        "values": []
-      },
-      "yaxes": [
-        {
-          "$$hashKey": "object:4372",
-          "format": "volt",
-          "label": "Volts",
-          "logBase": 1,
-          "show": true
-        },
-        {
-          "$$hashKey": "object:4373",
-          "format": "amp",
-          "label": "Amps",
-          "logBase": 1,
-          "show": true
-        }
-      ],
-      "yaxis": {
-        "align": false
-      }
-    },
     {
       "aliasColors": {
         "From grid": "#1f78c1",
@@ -1232,9 +1453,9 @@
       "fillGradient": 0,
       "gridPos": {
         "h": 8,
-        "w": 12,
+        "w": 10,
         "x": 12,
-        "y": 13
+        "y": 21
       },
       "hiddenSeries": false,
       "id": 10,
@@ -1258,7 +1479,7 @@
       },
       "paceLength": 10,
       "percentage": false,
-      "pluginVersion": "9.5.1",
+      "pluginVersion": "10.1.0",
       "pointradius": 2,
       "points": false,
       "renderer": "flot",
@@ -1416,6 +1637,25 @@
         "skipUrlSync": false,
         "sort": 0,
         "type": "query"
+      },
+      {
+        "datasource": {
+          "type": "postgres",
+          "uid": "PCC52D03280B7034C"
+        },
+        "definition": "SET vessel.id = '${__user.login}';\nSELECT rtrim(key, 'voltage') AS __text ,key AS __value FROM api.monitoring_view2 where key ILIKE 'electrical.batteries%voltage';",
+        "hide": 0,
+        "includeAll": false,
+        "label": "Batteries",
+        "multi": false,
+        "name": "batteries",
+        "options": [],
+        "query": "SET vessel.id = '${__user.login}';\nSELECT rtrim(key, 'voltage') AS __text ,key AS __value FROM api.monitoring_view2 where key ILIKE 'electrical.batteries%voltage';",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 0,
+        "type": "query"
       }
     ]
   },
@@ -1447,9 +1687,9 @@
       "30d"
     ]
   },
-  "timezone": "",
+  "timezone": "utc",
   "title": "Electrical System",
-  "uid": "rk0FTiIMk",
-  "version": 1,
+  "uid": "pgsail_tpl_electrical",
+  "version": 11,
   "weekStart": ""
 }

grafana/dashboards/tpl/Logbook.json

@@ -466,7 +466,7 @@
   "timepicker": {},
   "timezone": "utc",
   "title": "Logbook",
-  "uid": "E_FUkx9nk",
+  "uid": "pgsail_tpl_logbook",
   "version": 1,
   "weekStart": ""
 }

grafana/dashboards/tpl/Monitor.json

@@ -25,7 +25,7 @@
   "editable": true,
   "fiscalYearStartMonth": 0,
   "graphTooltip": 0,
-  "id": 2,
+  "id": 3,
   "links": [
     {
       "asDropdown": false,
@@ -92,7 +92,7 @@
         "text": {},
         "textMode": "auto"
       },
-      "pluginVersion": "9.4.3",
+      "pluginVersion": "10.1.0",
       "targets": [
         {
           "datasource": {
@@ -198,7 +198,7 @@
         "text": {},
         "textMode": "auto"
       },
-      "pluginVersion": "9.4.3",
+      "pluginVersion": "10.1.0",
       "targets": [
         {
           "datasource": {
@@ -279,6 +279,7 @@
               "tooltip": false,
               "viz": false
             },
+            "insertNulls": false,
             "lineInterpolation": "linear",
             "lineWidth": 1,
             "pointSize": 5,
@@ -439,6 +440,7 @@
               "tooltip": false,
               "viz": false
             },
+            "insertNulls": false,
             "lineInterpolation": "linear",
             "lineWidth": 1,
             "pointSize": 5,
@@ -573,6 +575,7 @@
               "tooltip": false,
               "viz": false
             },
+            "insertNulls": false,
             "lineInterpolation": "linear",
             "lineWidth": 1,
             "pointSize": 5,
@@ -638,7 +641,7 @@
           "group": [],
           "metricColumn": "none",
           "rawQuery": true,
-          "rawSql": "SET vessel.id = '${__user.login}';\nwith config as (select set_config('vessel.id', '${boat}', false) ) select * from api.monitoring_view",
+          "rawSql": "SET vessel.id = '${__user.login}';\nselect * from api.monitoring_humidity;\n",
           "refId": "A",
           "select": [
             [
@@ -679,11 +682,11 @@
           ]
         }
       ],
-      "title": "Title",
+      "title": "environment.%.humidity",
       "type": "timeseries"
     }
   ],
-  "refresh": "",
+  "refresh": "5m",
   "revision": 1,
   "schemaVersion": 38,
   "style": "dark",
@@ -729,7 +732,7 @@
   },
   "timezone": "utc",
   "title": "Monitor",
-  "uid": "apqDcPjMz",
+  "uid": "pgsail_tpl_monitor",
   "version": 1,
   "weekStart": ""
 }

grafana/dashboards/tpl/RPI.json

@@ -1335,7 +1335,7 @@
   },
   "timezone": "",
   "title": "RPI System",
-  "uid": "4kxYm6j7k",
+  "uid": "pgsail_tpl_rpi",
   "version": 1,
   "weekStart": ""
 }

grafana/dashboards/tpl/Solar.json

@@ -0,0 +1,635 @@
+{
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": {
+          "type": "datasource",
+          "uid": "grafana"
+        },
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "target": {
+          "limit": 100,
+          "matchAny": false,
+          "tags": [],
+          "type": "dashboard"
+        },
+        "type": "dashboard"
+      }
+    ]
+  },
+  "description": "Solar energy",
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 0,
+  "id": 5,
+  "links": [
+    {
+      "asDropdown": false,
+      "icon": "external link",
+      "includeVars": true,
+      "keepTime": false,
+      "tags": [],
+      "targetBlank": true,
+      "title": "New link",
+      "tooltip": "",
+      "type": "dashboards",
+      "url": ""
+    }
+  ],
+  "liveNow": false,
+  "panels": [
+    {
+      "datasource": {
+        "type": "postgres",
+        "uid": "PCC52D03280B7034C"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "decimals": 1,
+          "mappings": [
+            {
+              "options": {
+                "0": {
+                  "text": "Aus"
+                }
+              },
+              "type": "value"
+            },
+            {
+              "options": {
+                "match": "null",
+                "result": {
+                  "text": "Aus"
+                }
+              },
+              "type": "special"
+            }
+          ],
+          "max": 400,
+          "min": 0,
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "semi-dark-red",
+                "value": null
+              },
+              {
+                "color": "#EAB839",
+                "value": 32
+              },
+              {
+                "color": "dark-green",
+                "value": 50
+              },
+              {
+                "color": "semi-dark-green",
+                "value": 100
+              },
+              {
+                "color": "light-green",
+                "value": 200
+              }
+            ]
+          },
+          "unit": "watt"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 6,
+        "x": 0,
+        "y": 0
+      },
+      "id": 46,
+      "interval": "",
+      "options": {
+        "orientation": "auto",
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ],
+          "fields": "",
+          "values": false
+        },
+        "showThresholdLabels": false,
+        "showThresholdMarkers": true,
+        "text": {
+          "valueSize": 48
+        }
+      },
+      "pluginVersion": "10.1.0",
+      "targets": [
+        {
+          "alias": "Watt",
+          "datasource": {
+            "type": "postgres",
+            "uid": "PCC52D03280B7034C"
+          },
+          "editorMode": "code",
+          "format": "table",
+          "groupBy": [
+            {
+              "params": [
+                "$__interval"
+              ],
+              "type": "time"
+            }
+          ],
+          "measurement": "solarcharger/Yield/Power",
+          "orderByTime": "ASC",
+          "policy": "default",
+          "rawQuery": true,
+          "rawSql": "SET vessel.id = '${__user.login}';\nSELECT m.time, cast(m.metrics->'electrical.solar.Main.panelPower' as NUMERIC) as panelPower FROM api.metrics m WHERE $__timeFilter(time) AND m.vessel_id = '${boat}' LIMIT 1;\n",
+          "refId": "Watt",
+          "resultFormat": "time_series",
+          "select": [
+            [
+              {
+                "params": [
+                  "value"
+                ],
+                "type": "field"
+              },
+              {
+                "params": [],
+                "type": "last"
+              }
+            ]
+          ],
+          "sql": {
+            "columns": [
+              {
+                "parameters": [],
+                "type": "function"
+              }
+            ],
+            "groupBy": [
+              {
+                "property": {
+                  "type": "string"
+                },
+                "type": "groupBy"
+              }
+            ],
+            "limit": 50
+          },
+          "tags": []
+        }
+      ],
+      "transparent": true,
+      "type": "gauge"
+    },
+    {
+      "datasource": {
+        "type": "postgres",
+        "uid": "PCC52D03280B7034C"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "insertNulls": false,
+            "lineInterpolation": "smooth",
+            "lineStyle": {
+              "fill": "solid"
+            },
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "min": 0,
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          },
+          "unit": "watt"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 6,
+        "y": 0
+      },
+      "id": 48,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "postgres",
+            "uid": "PCC52D03280B7034C"
+          },
+          "editorMode": "code",
+          "format": "table",
+          "rawQuery": true,
+          "rawSql": "SET vessel.id = '${__user.login}';\nSELECT m.time, cast(m.metrics->'electrical.solar.Main.panelPower' as NUMERIC) as panelPower FROM api.metrics m WHERE $__timeFilter(time) AND m.vessel_id = '${boat}';\n",
+          "refId": "A",
+          "sql": {
+            "columns": [
+              {
+                "parameters": [],
+                "type": "function"
+              }
+            ],
+            "groupBy": [
+              {
+                "property": {
+                  "type": "string"
+                },
+                "type": "groupBy"
+              }
+            ],
+            "limit": 50
+          }
+        }
+      ],
+      "title": "panelPower",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "postgres",
+        "uid": "PCC52D03280B7034C"
+      },
+      "description": "",
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "Volts",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "insertNulls": false,
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          },
+          "unit": "volt"
+        },
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "current"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "blue",
+                  "mode": "fixed"
+                }
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "panelvoltage"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "yellow",
+                  "mode": "fixed"
+                }
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "current"
+            },
+            "properties": [
+              {
+                "id": "unit",
+                "value": "amp"
+              },
+              {
+                "id": "custom.axisLabel",
+                "value": "Amps"
+              }
+            ]
+          }
+        ]
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 18,
+        "x": 0,
+        "y": 8
+      },
+      "id": 47,
+      "options": {
+        "legend": {
+          "calcs": [
+            "mean",
+            "max",
+            "min"
+          ],
+          "displayMode": "list",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "none"
+        }
+      },
+      "pluginVersion": "10.1.0",
+      "targets": [
+        {
+          "datasource": {
+            "type": "postgres",
+            "uid": "PCC52D03280B7034C"
+          },
+          "editorMode": "code",
+          "format": "table",
+          "groupBy": [
+            {
+              "params": [
+                "$__interval"
+              ],
+              "type": "time"
+            },
+            {
+              "params": [
+                "null"
+              ],
+              "type": "fill"
+            }
+          ],
+          "measurement": "electrical.batteries.256.voltage",
+          "orderByTime": "ASC",
+          "policy": "default",
+          "rawQuery": true,
+          "rawSql": "SET vessel.id = '${__user.login}';\nSELECT m.time, cast(m.metrics->'electrical.solar.Main.panelVoltage' as NUMERIC) as panelVoltage FROM api.metrics m WHERE $__timeFilter(time) AND m.vessel_id = '${boat}';\n",
+          "refId": "A",
+          "resultFormat": "time_series",
+          "select": [
+            [
+              {
+                "params": [
+                  "value"
+                ],
+                "type": "field"
+              },
+              {
+                "params": [],
+                "type": "mean"
+              }
+            ]
+          ],
+          "sql": {
+            "columns": [
+              {
+                "parameters": [],
+                "type": "function"
+              }
+            ],
+            "groupBy": [
+              {
+                "property": {
+                  "type": "string"
+                },
+                "type": "groupBy"
+              }
+            ],
+            "limit": 50
+          },
+          "tags": []
+        },
+        {
+          "datasource": {
+            "type": "postgres",
+            "uid": "PCC52D03280B7034C"
+          },
+          "editorMode": "code",
+          "format": "table",
+          "groupBy": [
+            {
+              "params": [
+                "$__interval"
+              ],
+              "type": "time"
+            },
+            {
+              "params": [
+                "null"
+              ],
+              "type": "fill"
+            }
+          ],
+          "hide": false,
+          "measurement": "electrical.batteries.256.current",
+          "orderByTime": "ASC",
+          "policy": "default",
+          "query": "SELECT mean(\"value\") FROM \"electrical.batteries.256.current\" WHERE $timeFilter GROUP BY time($__interval) fill(null)",
+          "rawQuery": true,
+          "rawSql": "SET vessel.id = '${__user.login}';\nSELECT m.time, cast(m.metrics->'electrical.batteries.House.current' as NUMERIC) as current FROM api.metrics m WHERE $__timeFilter(time) AND m.vessel_id = '${boat}';\n",
+          "refId": "B",
+          "resultFormat": "time_series",
+          "select": [
+            [
+              {
+                "params": [
+                  "value"
+                ],
+                "type": "field"
+              },
+              {
+                "params": [],
+                "type": "mean"
+              }
+            ]
+          ],
+          "sql": {
+            "columns": [
+              {
+                "parameters": [],
+                "type": "function"
+              }
+            ],
+            "groupBy": [
+              {
+                "property": {
+                  "type": "string"
+                },
+                "type": "groupBy"
+              }
+            ],
+            "limit": 50
+          },
+          "tags": []
+        }
+      ],
+      "title": "panelVoltage",
+      "type": "timeseries"
+    }
+  ],
+  "refresh": "5m",
+  "schemaVersion": 38,
+  "style": "dark",
+  "tags": [],
+  "templating": {
+    "list": [
+      {
+        "datasource": {
+          "type": "postgres",
+          "uid": "PCC52D03280B7034C"
+        },
+        "definition": "SET \"user.email\" = '${__user.email}';\nSET vessel.id = '${__user.login}';\nSELECT\n        v.name AS __text,\n        m.vessel_id AS __value\n   FROM auth.vessels v\n   JOIN api.metadata m ON v.owner_email = '${__user.email}' and m.vessel_id = v.vessel_id;",
+        "description": "Vessel Name",
+        "hide": 0,
+        "includeAll": false,
+        "label": "Boat",
+        "multi": false,
+        "name": "boat",
+        "options": [],
+        "query": "SET \"user.email\" = '${__user.email}';\nSET vessel.id = '${__user.login}';\nSELECT\n        v.name AS __text,\n        m.vessel_id AS __value\n   FROM auth.vessels v\n   JOIN api.metadata m ON v.owner_email = '${__user.email}' and m.vessel_id = v.vessel_id;",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 0,
+        "type": "query"
+      },
+      {
+        "datasource": {
+          "type": "postgres",
+          "uid": "PCC52D03280B7034C"
+        },
+        "definition": "SET vessel.id = '${__user.login}';\nSELECT rtrim(key, 'panelVoltage') AS __text ,key AS __value FROM api.monitoring_view2 where key ILIKE 'electrical.solar%panelVoltage';",
+        "description": "Solar Panel",
+        "hide": 0,
+        "includeAll": false,
+        "label": "solarPanel",
+        "multi": false,
+        "name": "solar_panel",
+        "options": [],
+        "query": "SET vessel.id = '${__user.login}';\nSELECT rtrim(key, 'panelVoltage') AS __text ,key AS __value FROM api.monitoring_view2 where key ILIKE 'electrical.solar%panelVoltage';",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 0,
+        "type": "query"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-24h",
+    "to": "now"
+  },
+  "timepicker": {
+    "refresh_intervals": [
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ]
+  },
+  "timezone": "utc",
+  "title": "Solar System",
+  "uid": "pgsail_tpl_solar",
+  "version": 1,
+  "weekStart": ""
+}

grafana/dashboards/tpl/Weather.json

@@ -1936,7 +1936,7 @@
         "yBucketBound": "auto"
       }
     ],
-    "refresh": "1m",
+    "refresh": "5m",
     "schemaVersion": 37,
     "style": "dark",
     "tags": [],
@@ -1981,7 +1981,7 @@
     },
     "timezone": "utc",
     "title": "Weather",
-    "uid": "62bzzlr7z",
+    "uid": "pgsail_tpl_weather",
     "version": 1,
     "weekStart": ""
   }

grafana/dashboards/tpl/home.json

@@ -0,0 +1,297 @@
+{
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": {
+          "type": "grafana",
+          "uid": "-- Grafana --"
+        },
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "target": {
+          "limit": 100,
+          "matchAny": false,
+          "tags": [],
+          "type": "dashboard"
+        },
+        "type": "dashboard"
+      }
+    ]
+  },
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 0,
+  "id": 5,
+  "links": [
+    {
+      "asDropdown": false,
+      "icon": "external link",
+      "includeVars": true,
+      "keepTime": false,
+      "tags": [],
+      "targetBlank": true,
+      "title": "New link",
+      "tooltip": "",
+      "type": "dashboards",
+      "url": ""
+    }
+  ],
+  "liveNow": false,
+  "panels": [
+    {
+      "datasource": {
+        "type": "postgres",
+        "uid": "OIttR1sVk"
+      },
+      "gridPos": {
+        "h": 13,
+        "w": 10,
+        "x": 0,
+        "y": 0
+      },
+      "id": 3,
+      "links": [],
+      "options": {
+        "folderId": 0,
+        "includeVars": false,
+        "keepTime": false,
+        "maxItems": 30,
+        "query": "",
+        "showHeadings": true,
+        "showRecentlyViewed": true,
+        "showSearch": false,
+        "showStarred": true,
+        "tags": []
+      },
+      "pluginVersion": "10.1.4",
+      "tags": [],
+      "targets": [
+        {
+          "datasource": {
+            "type": "postgres",
+            "uid": "OIttR1sVk"
+          },
+          "refId": "A"
+        }
+      ],
+      "title": "PostgSail Dashboards",
+      "type": "dashlist"
+    },
+    {
+      "datasource": {
+        "type": "postgres",
+        "uid": "PCC52D03280B7034C"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "custom": {
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 13,
+        "w": 12,
+        "x": 10,
+        "y": 0
+      },
+      "id": 5,
+      "maxDataPoints": 500,
+      "options": {
+        "basemap": {
+          "config": {},
+          "name": "Layer 0",
+          "type": "default"
+        },
+        "controls": {
+          "mouseWheelZoom": true,
+          "showAttribution": true,
+          "showDebug": false,
+          "showMeasure": false,
+          "showScale": false,
+          "showZoom": true
+        },
+        "layers": [
+          {
+            "config": {
+              "showLegend": true,
+              "style": {
+                "color": {
+                  "fixed": "dark-green"
+                },
+                "opacity": 0.4,
+                "rotation": {
+                  "fixed": 0,
+                  "max": 360,
+                  "min": -360,
+                  "mode": "mod"
+                },
+                "size": {
+                  "fixed": 5,
+                  "max": 15,
+                  "min": 2
+                },
+                "symbol": {
+                  "fixed": "img/icons/marker/circle.svg",
+                  "mode": "fixed"
+                },
+                "textConfig": {
+                  "fontSize": 12,
+                  "offsetX": 0,
+                  "offsetY": 0,
+                  "textAlign": "center",
+                  "textBaseline": "middle"
+                }
+              }
+            },
+            "filterData": {
+              "id": "byRefId",
+              "options": "A"
+            },
+            "location": {
+              "latitude": "value",
+              "longitude": "value",
+              "mode": "auto"
+            },
+            "name": "Boat",
+            "tooltip": true,
+            "type": "markers"
+          }
+        ],
+        "tooltip": {
+          "mode": "details"
+        },
+        "view": {
+          "allLayers": true,
+          "id": "fit",
+          "lat": 0,
+          "lon": 0,
+          "zoom": 5
+        }
+      },
+      "pluginVersion": "10.1.4",
+      "targets": [
+        {
+          "datasource": {
+            "type": "postgres",
+            "uid": "PCC52D03280B7034C"
+          },
+          "editorMode": "code",
+          "format": "table",
+          "rawQuery": true,
+          "rawSql": "SELECT latitude, longitude FROM api.metrics WHERE vessel_id = '${boat}' ORDER BY time DESC LIMIT 1;",
+          "refId": "A",
+          "sql": {
+            "columns": [
+              {
+                "parameters": [],
+                "type": "function"
+              }
+            ],
+            "groupBy": [
+              {
+                "property": {
+                  "type": "string"
+                },
+                "type": "groupBy"
+              }
+            ],
+            "limit": 50
+          }
+        }
+      ],
+      "title": "Location",
+      "type": "geomap"
+    }
+  ],
+  "refresh": "",
+  "revision": 1,
+  "schemaVersion": 38,
+  "style": "dark",
+  "tags": [],
+  "templating": {
+    "list": [
+      {
+        "datasource": {
+          "type": "postgres",
+          "uid": "PCC52D03280B7034C"
+        },
+        "definition": "SET \"user.email\" = '${__user.email}';\nSET vessel.id = '${__user.login}';\nSELECT\n        v.name AS __text,\n        m.vessel_id AS __value\n   FROM auth.vessels v\n   JOIN api.metadata m ON v.owner_email = '${__user.email}' and m.vessel_id = v.vessel_id;",
+        "description": "Vessel Name",
+        "hide": 0,
+        "includeAll": false,
+        "label": "Boat",
+        "multi": false,
+        "name": "boat",
+        "options": [],
+        "query": "SET \"user.email\" = '${__user.email}';\nSET vessel.id = '${__user.login}';\nSELECT\n        v.name AS __text,\n        m.vessel_id AS __value\n   FROM auth.vessels v\n   JOIN api.metadata m ON v.owner_email = '${__user.email}' and m.vessel_id = v.vessel_id;",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 0,
+        "type": "query"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-90d",
+    "to": "now"
+  },
+  "timepicker": {
+    "hidden": true,
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ],
+    "time_options": [
+      "5m",
+      "15m",
+      "1h",
+      "6h",
+      "12h",
+      "24h",
+      "2d",
+      "7d",
+      "30d"
+    ],
+    "type": "timepicker"
+  },
+  "timezone": "browser",
+  "title": "Home",
+  "uid": "pgsail_tpl_home",
+  "version": 1,
+  "weekStart": ""
+}

grafana/grafana.ini

@@ -3,14 +3,22 @@ allow_sign_up = false
 auto_assign_org = true
 auto_assign_org_role = Editor
 
-[auth.proxy]
-enabled = true
-header_name = X-WEBAUTH-USER
-header_property = email
-auto_sign_up = true
-enable_login_token = true
-login_maximum_inactive_lifetime_duration = 12h
-login_maximum_lifetime_duration = 1d
-
 [dashboards]
-default_home_dashboard_path = /etc/grafana/dashboards/home.json
+default_home_dashboard_path = /etc/grafana/dashboards/tpl/home.json
+min_refresh_interval = 1m
+
+[alerting]
+enabled = false
+
+[unified_alerting]
+enabled = false
+
+[analytics]
+feedback_links_enabled = false
+reporting_enabled = false
+
+[news]
+news_feed_enabled = false
+
+[help]
+enabled = false

grafana/provisioning/dashboards/default.yaml

@@ -20,6 +20,6 @@ providers:
     allowUiUpdates: true
     options:
       # <string, required> path to dashboard files on disk. Required when using the 'file' type
-      path: /etc/grafana/dashboards/
+      path: /etc/grafana/dashboards/tpl/
       # <bool> use folder names from filesystem to create folders in Grafana
       foldersFromFilesStructure: true

grafana/provisioning/datasources/timescale.yaml

@@ -4,7 +4,7 @@ datasources:
   - name: PostgreSQL
     isDefault: true
     type: postgres
-    url: 172.30.0.1:5432
+    url: '${PGSAIL_GRAFANA_URI}'
     database: signalk
     user: grafana
     secureJsonData:

initdb/01signalk.sql

@@ -0,0 +1,83 @@
+---------------------------------------------------------------------------
+-- PostgSail => Postgres + TimescaleDB + PostGIS + PostgREST
+--
+-- Inspired from:
+-- https://groups.google.com/g/signalk/c/W2H15ODCic4
+--
+-- Description:
+-- Insert data into table api.metadata from API using PostgREST
+-- Insert data into table api.metrics from API using PostgREST
+-- TimescaleDB Hypertable to store signalk metrics on table api.metrics
+-- pgsql functions to generate logbook, stays, moorages from table api.metrics
+-- CRON functions to process logbook, stays, moorages
+-- python functions for geo reverse and send notification via email, pushover, telegram
+-- Views statistics, timelapse, monitoring, logs
+-- Always store time in UTC
+---------------------------------------------------------------------------
+
+-- vessels signalk -(POST)-> metadata -> metadata_upsert_trigger -(BEFORE INSERT)-> metadata_upsert_trigger_fn (INSERT or UPDATE)
+-- vessels signalk -(POST)-> metrics -> metrics_trigger -(BEFORE INSERT)-> metrics_trigger_fn (INSERT or UPDATE new log,stay)
+
+---------------------------------------------------------------------------
+
+-- Drop database
+-- % docker exec -i timescaledb-postgis psql -Uusername -W postgres -c "drop database signalk;"
+
+-- Import Schema
+-- % cat signalk.sql | docker exec -i timescaledb-postgis psql -Uusername postgres
+
+-- Export hypertable
+-- % docker exec -i timescaledb-postgis psql -Uusername -W signalk -c "\COPY (SELECT * FROM api.metrics ORDER BY time ASC) TO '/var/lib/postgresql/data/metrics.csv' DELIMITER ',' CSV"
+-- Export hypertable to gzip
+-- # docker exec -i timescaledb-postgis psql -Uusername -W signalk -c "\COPY (SELECT * FROM api.metrics ORDER BY time ASC) TO PROGRAM 'gzip > /var/lib/postgresql/data/metrics.csv.gz' CSV HEADER;"
+
+DO $$
+BEGIN
+RAISE WARNING '
+  _________.__                     .__   ____  __.
+ /   _____/|__| ____   ____ _____  |  | |    |/ _|
+ \_____  \ |  |/ ___\ /    \\__  \ |  | |      < 
+ /        \|  / /_/  >   |  \/ __ \|  |_|    |  \
+/_______  /|__\___  /|___|  (____  /____/____|__ \
+        \/   /_____/      \/     \/             \/
+ %', now();
+END $$;
+
+select version();
+
+-- Database
+CREATE DATABASE signalk;
+-- Limit connection to 100
+ALTER DATABASE signalk WITH CONNECTION LIMIT = 100;
+-- Set timezone to UTC
+ALTER DATABASE signalk SET TIMEZONE='UTC';
+-- Set datestyle output
+ALTER DATABASE signalk SET datestyle TO "ISO, DMY";
+-- Set intervalstyle output
+ALTER DATABASE signalk SET intervalstyle TO 'iso_8601';
+
+-- connect to the DB
+\c signalk
+
+-- Schema
+CREATE SCHEMA IF NOT EXISTS api;
+COMMENT ON SCHEMA api IS
+$$PostgSail API
+
+A RESTful API that serves PostgSail data using postgrest.$$;
+
+-- Revoke default privileges to all public functions
+ALTER DEFAULT PRIVILEGES REVOKE EXECUTE ON FUNCTIONS FROM PUBLIC;
+
+-- Extensions
+CREATE EXTENSION IF NOT EXISTS timescaledb; -- provides time series functions for PostgreSQL
+-- CREATE EXTENSION IF NOT EXISTS timescaledb_toolkit; -- provides time series functions for PostgreSQL
+CREATE EXTENSION IF NOT EXISTS postgis; -- adds support for geographic objects to the PostgreSQL object-relational database
+CREATE EXTENSION IF NOT EXISTS plpgsql; -- PL/pgSQL procedural language
+CREATE EXTENSION IF NOT EXISTS plpython3u; -- implements PL/Python based on the Python 3 language variant.
+CREATE EXTENSION IF NOT EXISTS jsonb_plpython3u CASCADE; -- tranform jsonb to python json type.
+CREATE EXTENSION IF NOT EXISTS pg_stat_statements; -- provides a means for tracking planning and execution statistics of all SQL statements executed
+CREATE EXTENSION IF NOT EXISTS "moddatetime"; -- provides functions for tracking last modification time
+
+-- Trust plpython3u language by default
+UPDATE pg_language SET lanpltrusted = true WHERE lanname = 'plpython3u';

initdb/02_1_1_signalk_api_tables.sql

@@ -0,0 +1,694 @@
+
+-- connect to the DB
+\c signalk
+
+---------------------------------------------------------------------------
+-- Tables
+--
+---------------------------------------------------------------------------
+-- Metadata from signalk
+CREATE TABLE IF NOT EXISTS api.metadata(
+  id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+  name TEXT NULL,
+  mmsi NUMERIC NULL,
+  client_id TEXT NULL,
+  -- vessel_id link auth.vessels with api.metadata
+  vessel_id TEXT NOT NULL UNIQUE,
+  length DOUBLE PRECISION NULL,
+  beam DOUBLE PRECISION NULL,
+  height DOUBLE PRECISION NULL,
+  ship_type NUMERIC NULL,
+  plugin_version TEXT NOT NULL,
+  signalk_version TEXT NOT NULL,
+  time TIMESTAMPTZ NOT NULL, -- should be rename to last_update !?
+  platform TEXT NULL,
+  configuration TEXT NULL,
+  active BOOLEAN DEFAULT True, -- trigger monitor online/offline
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+-- Description
+COMMENT ON TABLE
+    api.metadata
+    IS 'Stores metadata received from vessel, aka signalk plugin';
+COMMENT ON COLUMN api.metadata.active IS 'trigger monitor online/offline';
+COMMENT ON COLUMN api.metadata.vessel_id IS 'vessel_id link auth.vessels with api.metadata';
+-- Duplicate Indexes
+--CREATE INDEX metadata_vessel_id_idx ON api.metadata (vessel_id);
+
+---------------------------------------------------------------------------
+-- Metrics from signalk
+-- Create vessel status enum
+CREATE TYPE status_type AS ENUM ('sailing', 'motoring', 'moored', 'anchored');
+-- Table api.metrics
+CREATE TABLE IF NOT EXISTS api.metrics (
+  time TIMESTAMPTZ NOT NULL,
+  client_id TEXT NULL,
+  vessel_id TEXT NOT NULL REFERENCES api.metadata(vessel_id) ON DELETE RESTRICT,
+  latitude DOUBLE PRECISION NULL,
+  longitude DOUBLE PRECISION NULL,
+  speedOverGround DOUBLE PRECISION NULL,
+  courseOverGroundTrue DOUBLE PRECISION NULL,
+  windSpeedApparent DOUBLE PRECISION NULL,
+  angleSpeedApparent DOUBLE PRECISION NULL,
+  status TEXT NULL,
+  metrics JSONB NULL,
+  --CONSTRAINT valid_client_id CHECK (length(client_id) > 10),
+  --CONSTRAINT valid_latitude CHECK (latitude >= -90 and latitude <= 90),
+  --CONSTRAINT valid_longitude CHECK (longitude >= -180 and longitude <= 180),
+  PRIMARY KEY (time, vessel_id)
+);
+-- Description
+COMMENT ON TABLE
+    api.metrics
+    IS 'Stores metrics from vessel';
+COMMENT ON COLUMN api.metrics.latitude IS 'With CONSTRAINT but allow NULL value to be ignored silently by trigger';
+COMMENT ON COLUMN api.metrics.longitude IS 'With CONSTRAINT but allow NULL value to be ignored silently by trigger';
+
+-- Index
+CREATE INDEX ON api.metrics (vessel_id, time DESC);
+CREATE INDEX ON api.metrics (status, time DESC);
+-- json index??
+CREATE INDEX ON api.metrics using GIN (metrics);
+-- timescaledb hypertable
+SELECT create_hypertable('api.metrics', 'time', chunk_time_interval => INTERVAL '7 day');
+-- timescaledb hypertable with space partitions
+-- ERROR:  new row for relation "_hyper_1_2_chunk" violates check constraint "constraint_4"
+-- ((_timescaledb_internal.get_partition_hash(vessel_id) < 1073741823))
+--SELECT create_hypertable('api.metrics', 'time', 'vessel_id',
+--    number_partitions => 2,
+--    chunk_time_interval => INTERVAL '7 day',
+--    if_not_exists => true);
+
+---------------------------------------------------------------------------
+-- Logbook
+-- todo add consumption fuel?
+-- todo add engine hour?
+-- todo add geom object http://epsg.io/4326 EPSG:4326 Unit: degres
+-- todo add geog object http://epsg.io/3857 EPSG:3857 Unit: meters
+-- https://postgis.net/workshops/postgis-intro/geography.html#using-geography
+-- https://medium.com/coord/postgis-performance-showdown-geometry-vs-geography-ec99967da4f0
+-- virtual logbook by boat by client_id impossible? 
+-- https://www.postgresql.org/docs/current/ddl-partitioning.html
+-- Issue:
+-- https://www.reddit.com/r/PostgreSQL/comments/di5mbr/postgresql_12_foreign_keys_and_partitioned_tables/f3tsoop/
+-- Check unused index
+
+CREATE TABLE IF NOT EXISTS api.logbook(
+  id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+  vessel_id TEXT NOT NULL REFERENCES api.metadata(vessel_id) ON DELETE RESTRICT,
+  active BOOLEAN DEFAULT false,
+  name TEXT,
+  _from_moorage_id INT NULL,
+  _from TEXT,
+  _from_lat DOUBLE PRECISION NULL,
+  _from_lng DOUBLE PRECISION NULL,
+  _to_moorage_id INT NULL,
+  _to TEXT,
+  _to_lat DOUBLE PRECISION NULL,
+  _to_lng DOUBLE PRECISION NULL,
+  --track_geom Geometry(LINESTRING)
+  track_geom geometry(LINESTRING,4326) NULL,
+  track_geog geography(LINESTRING) NULL,
+  track_geojson JSONB NULL,
+  _from_time TIMESTAMPTZ NOT NULL,
+  _to_time TIMESTAMPTZ NULL,
+  distance NUMERIC, -- meters?
+  duration INTERVAL, -- duration in days and hours?
+  avg_speed DOUBLE PRECISION NULL,
+  max_speed DOUBLE PRECISION NULL,
+  max_wind_speed DOUBLE PRECISION NULL,
+  notes TEXT NULL, -- remarks
+  extra JSONB NULL -- computed signalk metrics of interest
+);
+-- Description
+COMMENT ON TABLE
+    api.logbook
+    IS 'Stores generated logbook';
+COMMENT ON COLUMN api.logbook.distance IS 'in NM';
+COMMENT ON COLUMN api.logbook.extra IS 'computed signalk metrics of interest, runTime, currentLevel, etc';
+COMMENT ON COLUMN api.logbook.duration IS 'Best to use standard ISO 8601';
+
+-- Index todo!
+CREATE INDEX logbook_vessel_id_idx ON api.logbook (vessel_id);
+CREATE INDEX logbook_from_time_idx ON api.logbook (_from_time);
+CREATE INDEX logbook_to_time_idx ON api.logbook (_to_time);
+CREATE INDEX logbook_from_moorage_id_idx ON api.logbook (_from_moorage_id);
+CREATE INDEX logbook_to_moorage_id_idx ON api.logbook (_to_moorage_id);
+CREATE INDEX ON api.logbook USING GIST ( track_geom );
+COMMENT ON COLUMN api.logbook.track_geom IS 'postgis geometry type EPSG:4326 Unit: degres';
+CREATE INDEX ON api.logbook USING GIST ( track_geog );
+COMMENT ON COLUMN api.logbook.track_geog IS 'postgis geography type default SRID 4326 Unit: degres';
+-- Otherwise -- ERROR:  Only lon/lat coordinate systems are supported in geography.
+COMMENT ON COLUMN api.logbook.track_geojson IS 'store generated geojson with track metrics data using with LineString and Point features, we can not depend api.metrics table';
+
+---------------------------------------------------------------------------
+-- Stays
+-- virtual logbook by boat? 
+CREATE TABLE IF NOT EXISTS api.stays(
+  id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+  vessel_id TEXT NOT NULL REFERENCES api.metadata(vessel_id) ON DELETE RESTRICT,
+  active BOOLEAN DEFAULT false,
+  moorage_id INT NULL,
+  name TEXT,
+  latitude DOUBLE PRECISION NULL,
+  longitude DOUBLE PRECISION NULL,
+  geog GEOGRAPHY(POINT) NULL,
+  arrived TIMESTAMPTZ NOT NULL,
+  departed TIMESTAMPTZ,
+  duration INTERVAL, -- duration in days and hours?
+  stay_code INT DEFAULT 1, -- REFERENCES api.stays_at(stay_code),
+  notes TEXT NULL
+);
+-- Description
+COMMENT ON TABLE
+    api.stays
+    IS 'Stores generated stays';
+COMMENT ON COLUMN api.stays.duration IS 'Best to use standard ISO 8601';
+
+-- Index
+CREATE INDEX stays_vessel_id_idx ON api.stays (vessel_id);
+CREATE INDEX stays_moorage_id_idx ON api.stays (moorage_id);
+CREATE INDEX ON api.stays USING GIST ( geog );
+COMMENT ON COLUMN api.stays.geog IS 'postgis geography type default SRID 4326 Unit: degres';
+-- With other SRID ERROR: Only lon/lat coordinate systems are supported in geography.
+
+---------------------------------------------------------------------------
+-- Moorages
+-- virtual logbook by boat? 
+CREATE TABLE IF NOT EXISTS api.moorages(
+  id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+  vessel_id TEXT NOT NULL REFERENCES api.metadata(vessel_id) ON DELETE RESTRICT,
+  name TEXT,
+  country TEXT,
+  stay_code INT DEFAULT 1, -- needed?  REFERENCES api.stays_at(stay_code)
+  stay_duration INTERVAL NULL,
+  reference_count INT DEFAULT 1,
+  latitude DOUBLE PRECISION NULL,
+  longitude DOUBLE PRECISION NULL,
+  geog GEOGRAPHY(POINT) NULL,
+  home_flag BOOLEAN DEFAULT false,
+  notes TEXT NULL,
+  overpass JSONB NULL,
+  nominatim JSONB NULL
+);
+-- Description
+COMMENT ON TABLE
+    api.moorages
+    IS 'Stores generated moorages';
+
+-- Index
+CREATE INDEX moorages_vessel_id_idx ON api.moorages (vessel_id);
+CREATE INDEX ON api.moorages USING GIST ( geog );
+COMMENT ON COLUMN api.moorages.geog IS 'postgis geography type default SRID 4326 Unit: degres';
+-- With other SRID ERROR: Only lon/lat coordinate systems are supported in geography.
+COMMENT ON COLUMN api.moorages.stay_duration IS 'Best to use standard ISO 8601';
+
+---------------------------------------------------------------------------
+-- Stay Type
+CREATE TABLE IF NOT EXISTS api.stays_at(
+  stay_code   INTEGER UNIQUE NOT NULL,
+  description TEXT NOT NULL
+);
+-- Description
+COMMENT ON TABLE api.stays_at IS 'Stay Type';
+-- Insert default possible values
+INSERT INTO api.stays_at(stay_code, description) VALUES
+  (1, 'Unknown'),
+  (2, 'Anchor'),
+  (3, 'Mooring Buoy'),
+  (4, 'Dock');
+
+---------------------------------------------------------------------------
+-- Trigger Functions Metadata table
+--
+-- UPSERT - Insert vs Update for Metadata
+DROP FUNCTION IF EXISTS metadata_upsert_trigger_fn; 
+CREATE FUNCTION metadata_upsert_trigger_fn() RETURNS trigger AS $metadata_upsert$
+    DECLARE
+        metadata_id integer;
+        metadata_active boolean;
+    BEGIN
+        -- Set client_id to new value to allow RLS
+        --PERFORM set_config('vessel.client_id', NEW.client_id, false);
+        -- UPSERT - Insert vs Update for Metadata
+        --RAISE NOTICE 'metadata_upsert_trigger_fn';
+        --PERFORM set_config('vessel.id', NEW.vessel_id, true);
+        --RAISE WARNING 'metadata_upsert_trigger_fn [%] [%]', current_setting('vessel.id', true), NEW;
+        SELECT m.id,m.active INTO metadata_id, metadata_active
+            FROM api.metadata m
+            WHERE m.vessel_id IS NOT NULL AND m.vessel_id = current_setting('vessel.id', true);
+        --RAISE NOTICE 'metadata_id is [%]', metadata_id;
+        IF metadata_id IS NOT NULL THEN
+            -- send notification if boat is back online
+            IF metadata_active is False THEN
+                -- Add monitor online entry to process queue for later notification
+                INSERT INTO process_queue (channel, payload, stored, ref_id)
+                    VALUES ('monitoring_online', metadata_id, now(), current_setting('vessel.id', true));
+            END IF;
+            -- Update vessel metadata
+            UPDATE api.metadata
+                SET
+                    name = NEW.name,
+                    mmsi = NEW.mmsi,
+                    client_id = NEW.client_id,
+                    length = NEW.length,
+                    beam = NEW.beam,
+                    height = NEW.height,
+                    ship_type = NEW.ship_type,
+                    plugin_version = NEW.plugin_version,
+                    signalk_version = NEW.signalk_version,
+                    platform = NEW.platform,
+                    configuration = NEW.configuration,
+                    -- time = NEW.time, ignore the time sent by the vessel as it is out of sync sometimes.
+                    time = NOW(), -- overwrite the time sent by the vessel
+                    active = true
+                WHERE id = metadata_id;
+            RETURN NULL; -- Ignore insert
+        ELSE
+            IF NEW.vessel_id IS NULL THEN
+                -- set vessel_id from jwt if not present in INSERT query
+                NEW.vessel_id := current_setting('vessel.id');
+            END IF;
+            -- Ignore and overwrite the time sent by the vessel
+            NEW.time := NOW();
+            -- Insert new vessel metadata
+            RETURN NEW; -- Insert new vessel metadata
+        END IF;
+    END;
+$metadata_upsert$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.metadata_upsert_trigger_fn
+    IS 'process metadata from vessel, upsert';
+
+CREATE TRIGGER metadata_moddatetime
+	BEFORE UPDATE ON api.metadata
+	FOR EACH ROW
+	EXECUTE PROCEDURE moddatetime (updated_at);
+-- Description
+COMMENT ON TRIGGER metadata_moddatetime
+  ON api.metadata
+  IS 'Automatic update of updated_at on table modification';
+
+-- FUNCTION Metadata notification for new vessel after insert
+DROP FUNCTION IF EXISTS metadata_notification_trigger_fn; 
+CREATE FUNCTION metadata_notification_trigger_fn() RETURNS trigger AS $metadata_notification$
+    DECLARE
+    BEGIN
+        RAISE NOTICE 'metadata_notification_trigger_fn [%]', NEW;
+        INSERT INTO process_queue (channel, payload, stored, ref_id)
+            VALUES ('monitoring_online', NEW.id, now(), NEW.vessel_id);
+        RETURN NULL;
+    END;
+$metadata_notification$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.metadata_notification_trigger_fn
+    IS 'process metadata notification from vessel, monitoring_online';
+
+-- FUNCTION Metadata grafana provisioning for new vessel after insert
+DROP FUNCTION IF EXISTS metadata_grafana_trigger_fn;
+CREATE FUNCTION metadata_grafana_trigger_fn() RETURNS trigger AS $metadata_grafana$
+    DECLARE
+    BEGIN
+        RAISE NOTICE 'metadata_grafana_trigger_fn [%]', NEW;
+        INSERT INTO process_queue (channel, payload, stored, ref_id)
+            VALUES ('grafana', NEW.id, now(), NEW.vessel_id);
+        RETURN NULL;
+    END;
+$metadata_grafana$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.metadata_grafana_trigger_fn
+    IS 'process metadata grafana provisioning from vessel';
+
+---------------------------------------------------------------------------
+-- Trigger metadata table
+--
+-- Metadata trigger BEFORE INSERT
+CREATE TRIGGER metadata_upsert_trigger BEFORE INSERT ON api.metadata
+    FOR EACH ROW EXECUTE FUNCTION metadata_upsert_trigger_fn();
+-- Description
+COMMENT ON TRIGGER
+    metadata_upsert_trigger ON api.metadata
+    IS 'BEFORE INSERT ON api.metadata run function metadata_upsert_trigger_fn';
+
+-- Metadata trigger AFTER INSERT
+CREATE TRIGGER metadata_notification_trigger AFTER INSERT ON api.metadata
+    FOR EACH ROW EXECUTE FUNCTION metadata_notification_trigger_fn();
+-- Description
+COMMENT ON TRIGGER 
+    metadata_notification_trigger ON api.metadata 
+    IS 'AFTER INSERT ON api.metadata run function metadata_notification_trigger_fn for later notification on new vessel';
+
+-- Metadata trigger AFTER INSERT
+CREATE TRIGGER metadata_grafana_trigger AFTER INSERT ON api.metadata
+    FOR EACH ROW EXECUTE FUNCTION metadata_grafana_trigger_fn();
+-- Description
+COMMENT ON TRIGGER 
+    metadata_grafana_trigger ON api.metadata 
+    IS 'AFTER INSERT ON api.metadata run function metadata_grafana_trigger_fn for later grafana provisioning on new vessel';
+
+---------------------------------------------------------------------------
+-- Trigger Functions metrics table
+--
+-- Create a logbook or stay entry base on the vessel state, eg: navigation.state
+-- https://github.com/meri-imperiumi/signalk-autostate
+
+DROP FUNCTION IF EXISTS metrics_trigger_fn;
+CREATE FUNCTION metrics_trigger_fn() RETURNS trigger AS $metrics$
+    DECLARE
+        previous_metric record;
+        stay_code INTEGER;
+        logbook_id INTEGER;
+        stay_id INTEGER;
+        valid_status BOOLEAN := False;
+        _vessel_id TEXT;
+        distance BOOLEAN := False;
+    BEGIN
+        --RAISE NOTICE 'metrics_trigger_fn';
+        --RAISE WARNING 'metrics_trigger_fn [%] [%]', current_setting('vessel.id', true), NEW;
+        -- Ensure vessel.id to new value to allow RLS
+        IF NEW.vessel_id IS NULL THEN
+            -- set vessel_id from jwt if not present in INSERT query
+            NEW.vessel_id := current_setting('vessel.id');
+        END IF;
+        -- Boat metadata are check using api.metrics REFERENCES to api.metadata
+        -- Fetch the latest entry to compare status against the new status to be insert
+        SELECT * INTO previous_metric
+            FROM api.metrics m 
+            WHERE m.vessel_id IS NOT NULL
+                AND m.vessel_id = current_setting('vessel.id', true)
+            ORDER BY m.time DESC LIMIT 1;
+        --RAISE NOTICE 'Metrics Status, New:[%] Previous:[%]', NEW.status, previous_metric.status;
+        IF previous_metric.time = NEW.time THEN
+            -- Ignore entry if same time
+            RAISE WARNING 'Metrics Ignoring metric, vessel_id [%], duplicate time [%] = [%]', NEW.vessel_id, previous_metric.time, NEW.time;
+            RETURN NULL;
+        END IF;
+        IF previous_metric.time > NEW.time THEN
+            -- Ignore entry if new time is later than previous time
+            RAISE WARNING 'Metrics Ignoring metric, vessel_id [%], new time is older than previous_metric.time [%] > [%]', NEW.vessel_id, previous_metric.time, NEW.time;
+            RETURN NULL;
+        END IF;
+        -- Check if latitude or longitude are type double
+        --IF public.isdouble(NEW.latitude::TEXT) IS False OR public.isdouble(NEW.longitude::TEXT) IS False THEN
+        --    -- Ignore entry if null latitude,longitude
+        --    RAISE WARNING 'Metrics Ignoring metric, vessel_id [%], not a double type for latitude or longitude [%] [%]', NEW.vessel_id, NEW.latitude, NEW.longitude;
+        --    RETURN NULL;
+        --END IF;
+        -- Check if latitude or longitude are null
+        IF NEW.latitude IS NULL OR NEW.longitude IS NULL THEN
+            -- Ignore entry if null latitude,longitude
+            RAISE WARNING 'Metrics Ignoring metric, vessel_id [%], null latitude or longitude [%] [%]', NEW.vessel_id, NEW.latitude, NEW.longitude;
+            RETURN NULL;
+        END IF;
+        -- Check if valid latitude
+        IF NEW.latitude >= 90 OR NEW.latitude <= -90 THEN
+            -- Ignore entry if invalid latitude,longitude
+            RAISE WARNING 'Metrics Ignoring metric, vessel_id [%], invalid latitude >= 90 OR <= -90 [%] [%]', NEW.vessel_id, NEW.latitude, NEW.longitude;
+            RETURN NULL;
+        END IF;
+        -- Check if valid longitude
+        IF NEW.longitude >= 180 OR NEW.longitude <= -180 THEN
+            -- Ignore entry if invalid latitude,longitude
+            RAISE WARNING 'Metrics Ignoring metric, vessel_id [%], invalid longitude >= 180 OR <= -180 [%] [%]', NEW.vessel_id, NEW.latitude, NEW.longitude;
+            RETURN NULL;
+        END IF;
+        -- Check if valid longitude and latitude not close to -0.0000001 from Victron Cerbo
+        IF NEW.latitude = NEW.longitude THEN
+            -- Ignore entry if latitude,longitude are equal
+            RAISE WARNING 'Metrics Ignoring metric, vessel_id [%], latitude and longitude are equal [%] [%]', NEW.vessel_id, NEW.latitude, NEW.longitude;
+            RETURN NULL;
+        END IF;
+        -- Check distance with previous point is > 10km
+        --SELECT ST_Distance(
+        --    ST_MakePoint(NEW.latitude,NEW.longitude)::geography,
+        --    ST_MakePoint(previous_metric.latitude,previous_metric.longitude)::geography) > 10000 INTO distance;
+        --IF distance IS True THEN
+        --    RAISE WARNING 'Metrics Ignoring metric, distance between previous metric and new metric is too large, vessel_id [%] distance[%]', NEW.vessel_id, distance;
+        --    RETURN NULL;
+        --END IF;
+        -- Check if status is null but speed is over 3knots set status to sailing
+        IF NEW.status IS NULL AND NEW.speedoverground >= 3 THEN
+            RAISE WARNING 'Metrics Unknown NEW.status, vessel_id [%], null status, set to sailing because of speedoverground is +3 from [%]', NEW.vessel_id, NEW.status;
+            NEW.status := 'sailing';
+        -- Check if status is null then set status to default moored
+        ELSIF NEW.status IS NULL THEN
+            RAISE WARNING 'Metrics Unknown NEW.status, vessel_id [%], null status, set to default moored from [%]', NEW.vessel_id, NEW.status;
+            NEW.status := 'moored';
+        END IF;
+        IF previous_metric.status IS NULL THEN
+            IF NEW.status = 'anchored' THEN
+                RAISE WARNING 'Metrics Unknown previous_metric.status from vessel_id [%], [%] set to default current status [%]', NEW.vessel_id, previous_metric.status, NEW.status;
+                previous_metric.status := NEW.status;
+            ELSE
+                RAISE WARNING 'Metrics Unknown previous_metric.status from vessel_id [%], [%] set to default status moored vs [%]', NEW.vessel_id, previous_metric.status, NEW.status;
+                previous_metric.status := 'moored';
+            END IF;
+            -- Add new stay as no previous entry exist
+            INSERT INTO api.stays 
+                (vessel_id, active, arrived, latitude, longitude, stay_code)
+                VALUES (current_setting('vessel.id', true), true, NEW.time, NEW.latitude, NEW.longitude, 1)
+                RETURNING id INTO stay_id;
+            -- Add stay entry to process queue for further processing
+            INSERT INTO process_queue (channel, payload, stored, ref_id)
+                VALUES ('new_stay', stay_id, now(), current_setting('vessel.id', true));
+            RAISE WARNING 'Metrics Insert first stay as no previous metrics exist, stay_id stay_id [%] [%] [%]', stay_id, NEW.status, NEW.time;
+        END IF;
+        -- Check if status is valid enum
+        SELECT NEW.status::name = any(enum_range(null::status_type)::name[]) INTO valid_status;
+        IF valid_status IS False THEN
+            -- Ignore entry if status is invalid
+            RAISE WARNING 'Metrics Ignoring metric, vessel_id [%], invalid status [%]', NEW.vessel_id, NEW.status;
+            RETURN NULL;
+        END IF;
+        -- Check if speedOverGround is valid value
+        IF NEW.speedoverground >= 40 THEN
+            -- Ignore entry as speedOverGround is invalid
+            RAISE WARNING 'Metrics Ignoring metric, vessel_id [%], speedOverGround is invalid, over 40 < [%]', NEW.vessel_id, NEW.speedoverground;
+            RETURN NULL;
+        END IF;
+
+        -- Check the state and if any previous/current entry
+        -- If change of state and new status is sailing or motoring
+        IF previous_metric.status::TEXT <> NEW.status::TEXT AND
+            ( (NEW.status::TEXT = 'sailing' AND previous_metric.status::TEXT <> 'motoring')
+             OR (NEW.status::TEXT = 'motoring' AND previous_metric.status::TEXT <> 'sailing') ) THEN
+            RAISE WARNING 'Metrics Update status, try new logbook, New:[%] Previous:[%]', NEW.status, previous_metric.status;
+            -- Start new log
+            logbook_id := public.trip_in_progress_fn(current_setting('vessel.id', true)::TEXT);
+            IF logbook_id IS NULL THEN
+                INSERT INTO api.logbook
+                    (vessel_id, active, _from_time, _from_lat, _from_lng)
+                    VALUES (current_setting('vessel.id', true), true, NEW.time, NEW.latitude, NEW.longitude)
+                    RETURNING id INTO logbook_id;
+                RAISE WARNING 'Metrics Insert new logbook, logbook_id [%] [%] [%]', logbook_id, NEW.status, NEW.time;
+            ELSE
+                UPDATE api.logbook
+                    SET
+                        active = false,
+                        _to_time = NEW.time,
+                        _to_lat = NEW.latitude,
+                        _to_lng = NEW.longitude
+                    WHERE id = logbook_id;
+                RAISE WARNING 'Metrics Existing logbook logbook_id [%] [%] [%]', logbook_id, NEW.status, NEW.time;
+            END IF;
+
+            -- End current stay
+            stay_id := public.stay_in_progress_fn(current_setting('vessel.id', true)::TEXT);
+            IF stay_id IS NOT NULL THEN
+                UPDATE api.stays
+                    SET
+                        active = false,
+                        departed = NEW.time
+                    WHERE id = stay_id;
+                -- Add stay entry to process queue for further processing
+                INSERT INTO process_queue (channel, payload, stored, ref_id)
+                    VALUES ('new_stay', stay_id, NOW(), current_setting('vessel.id', true));
+                RAISE WARNING 'Metrics Updating Stay end current stay_id [%] [%] [%]', stay_id, NEW.status, NEW.time;
+            ELSE
+                RAISE WARNING 'Metrics Invalid stay_id [%] [%]', stay_id, NEW.time;
+            END IF;
+
+        -- If change of state and new status is moored or anchored
+        ELSIF previous_metric.status::TEXT <> NEW.status::TEXT AND
+            ( (NEW.status::TEXT = 'moored' AND previous_metric.status::TEXT <> 'anchored')
+             OR (NEW.status::TEXT = 'anchored' AND previous_metric.status::TEXT <> 'moored') ) THEN
+            -- Start new stays
+            RAISE WARNING 'Metrics Update status, try new stay, New:[%] Previous:[%]', NEW.status, previous_metric.status;
+            stay_id := public.stay_in_progress_fn(current_setting('vessel.id', true)::TEXT);
+            IF stay_id IS NULL THEN
+                RAISE WARNING 'Metrics Inserting new stay [%]', NEW.status;
+                -- If metric status is anchored set stay_code accordingly
+                stay_code = 1;
+                IF NEW.status = 'anchored' THEN
+                    stay_code = 2;
+                END IF;
+                -- Add new stay
+                INSERT INTO api.stays
+                    (vessel_id, active, arrived, latitude, longitude, stay_code)
+                    VALUES (current_setting('vessel.id', true), true, NEW.time, NEW.latitude, NEW.longitude, stay_code)
+                    RETURNING id INTO stay_id;
+                RAISE WARNING 'Metrics Insert new stay, stay_id [%] [%] [%]', stay_id, NEW.status, NEW.time;
+            ELSE
+                RAISE WARNING 'Metrics Invalid stay_id [%] [%]', stay_id, NEW.time;
+                UPDATE api.stays
+                    SET
+                        active = false,
+                        departed = NEW.time,
+                        notes = 'Invalid stay?'
+                    WHERE id = stay_id;
+            END IF;
+
+            -- End current log/trip
+            -- Fetch logbook_id by vessel_id
+            logbook_id := public.trip_in_progress_fn(current_setting('vessel.id', true)::TEXT);
+            IF logbook_id IS NOT NULL THEN
+                -- todo check on time start vs end
+                RAISE WARNING 'Metrics Updating logbook status [%] [%] [%]', logbook_id, NEW.status, NEW.time;
+                UPDATE api.logbook 
+                    SET 
+                        active = false, 
+                        _to_time = NEW.time,
+                        _to_lat = NEW.latitude,
+                        _to_lng = NEW.longitude
+                    WHERE id = logbook_id;
+                -- Add logbook entry to process queue for later processing
+                INSERT INTO process_queue (channel, payload, stored, ref_id)
+                    VALUES ('pre_logbook', logbook_id, NOW(), current_setting('vessel.id', true));
+            ELSE
+                RAISE WARNING 'Metrics Invalid logbook_id [%] [%] [%]', logbook_id, NEW.status, NEW.time;
+            END IF;
+        END IF;
+        RETURN NEW; -- Finally insert the actual new metric
+    END;
+$metrics$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.metrics_trigger_fn
+    IS 'process metrics from vessel, generate pre_logbook and new_stay.';
+
+--
+-- Triggers logbook update on metrics insert
+CREATE TRIGGER metrics_trigger BEFORE INSERT ON api.metrics
+    FOR EACH ROW EXECUTE FUNCTION metrics_trigger_fn();
+-- Description
+COMMENT ON TRIGGER 
+    metrics_trigger ON api.metrics 
+    IS  'BEFORE INSERT ON api.metrics run function metrics_trigger_fn';
+
+-- Function update of name and stay_code on logbook and stays reference
+DROP FUNCTION IF EXISTS moorage_update_trigger_fn;
+CREATE FUNCTION moorage_update_trigger_fn() RETURNS trigger AS $moorage_update$
+    DECLARE
+    BEGIN
+        RAISE NOTICE 'moorages_update_trigger_fn [%]', NEW;
+        IF ( OLD.name != NEW.name) THEN
+            UPDATE api.logbook SET _from = NEW.name WHERE _from_moorage_id = NEW.id;
+            UPDATE api.logbook SET _to = NEW.name WHERE _to_moorage_id = NEW.id;
+        END IF;
+        IF ( OLD.stay_code != NEW.stay_code) THEN
+            UPDATE api.stays SET stay_code = NEW.stay_code WHERE moorage_id = NEW.id;
+        END IF;
+        RETURN NULL; -- result is ignored since this is an AFTER trigger
+    END;
+$moorage_update$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.moorage_update_trigger_fn
+    IS 'Automatic update of name and stay_code on logbook and stays reference';
+
+-- Triggers moorage update after update
+CREATE TRIGGER moorage_update_trigger AFTER UPDATE ON api.moorages
+    FOR EACH ROW EXECUTE FUNCTION moorage_update_trigger_fn();
+-- Description
+COMMENT ON TRIGGER moorage_update_trigger
+  ON api.moorages
+  IS 'Automatic update of name and stay_code on logbook and stays reference';
+
+-- Function delete logbook and stays reference when delete a moorage
+DROP FUNCTION IF EXISTS moorage_delete_trigger_fn;
+CREATE FUNCTION moorage_delete_trigger_fn() RETURNS trigger AS $moorage_delete$
+    DECLARE
+    BEGIN
+        RAISE NOTICE 'moorages_delete_trigger_fn [%]', OLD;
+        DELETE FROM api.stays WHERE moorage_id = OLD.id;
+        DELETE FROM api.logbook WHERE _from_moorage_id = OLD.id;
+        DELETE FROM api.logbook WHERE _to_moorage_id = OLD.id;
+        RETURN OLD; -- result is ignored since this is an AFTER trigger
+    END;
+$moorage_delete$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.moorage_delete_trigger_fn
+    IS 'Automatic delete logbook and stays reference when delete a moorage';
+
+-- Triggers moorage delete
+CREATE TRIGGER moorage_delete_trigger BEFORE DELETE ON api.moorages
+    FOR EACH ROW EXECUTE FUNCTION moorage_delete_trigger_fn();
+-- Description
+COMMENT ON TRIGGER moorage_delete_trigger
+  ON api.moorages
+  IS 'Automatic delete logbook and stays reference when delete a moorage';
+
+-- Function process_new on completed logbook
+DROP FUNCTION IF EXISTS logbook_completed_trigger_fn;
+CREATE FUNCTION logbook_completed_trigger_fn() RETURNS trigger AS $logbook_completed$
+    DECLARE
+    BEGIN
+        RAISE NOTICE 'logbook_completed_trigger_fn [%]', OLD;
+        RAISE NOTICE 'logbook_completed_trigger_fn [%] [%]', OLD._to_time, NEW._to_time;
+        -- Add logbook entry to process queue for later processing
+        --IF ( OLD._to_time <> NEW._to_time ) THEN
+            INSERT INTO process_queue (channel, payload, stored, ref_id)
+                VALUES ('new_logbook', NEW.id, NOW(), current_setting('vessel.id', true));
+        --END IF;
+        RETURN OLD; -- result is ignored since this is an AFTER trigger
+    END;
+$logbook_completed$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.logbook_completed_trigger_fn
+    IS 'Automatic process_queue for completed logbook._to_time';
+
+-- Triggers logbook completed
+--CREATE TRIGGER logbook_completed_trigger AFTER UPDATE ON api.logbook
+--    FOR EACH ROW
+--    WHEN (OLD._to_time IS DISTINCT FROM NEW._to_time)
+--    EXECUTE FUNCTION logbook_completed_trigger_fn();
+-- Description
+--COMMENT ON TRIGGER logbook_completed_trigger
+--  ON api.logbook
+--  IS 'Automatic process_queue for completed logbook';
+
+-- Function process_new on completed Stay
+DROP FUNCTION IF EXISTS stay_completed_trigger_fn;
+CREATE FUNCTION stay_completed_trigger_fn() RETURNS trigger AS $stay_completed$
+    DECLARE
+    BEGIN
+        RAISE NOTICE 'stay_completed_trigger_fn [%]', OLD;
+        RAISE NOTICE 'stay_completed_trigger_fn [%] [%]', OLD.departed, NEW.departed;
+        -- Add stay entry to process queue for later processing
+        --IF ( OLD.departed <> NEW.departed ) THEN
+            INSERT INTO process_queue (channel, payload, stored, ref_id)
+                VALUES ('new_stay', NEW.id, NOW(), current_setting('vessel.id', true));
+        --END IF;
+        RETURN OLD; -- result is ignored since this is an AFTER trigger
+    END;
+$stay_completed$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.stay_completed_trigger_fn
+    IS 'Automatic process_queue for completed stay.departed';
+
+-- Triggers stay completed
+--CREATE TRIGGER stay_completed_trigger AFTER UPDATE ON api.stays
+--    FOR EACH ROW
+--    WHEN (OLD.departed IS DISTINCT FROM NEW.departed)
+--    EXECUTE FUNCTION stay_completed_trigger_fn();
+-- Description
+--COMMENT ON TRIGGER stay_completed_trigger
+--  ON api.stays
+--  IS 'Automatic process_queue for completed stay';

initdb/02_1_2_signalk_api_functions.sql

@@ -0,0 +1,938 @@
+
+-- connect to the DB
+\c signalk
+
+---------------------------------------------------------------------------
+-- API helper functions
+--
+---------------------------------------------------------------------------
+
+-- PostgREST Media Type Handlers
+CREATE DOMAIN "text/xml" AS xml;
+CREATE DOMAIN "application/geo+json" AS jsonb;
+CREATE DOMAIN "application/gpx+xml" AS xml;
+CREATE DOMAIN "application/vnd.google-earth.kml+xml" AS xml;
+
+---------------------------------------------------------------------------
+-- Functions API schema
+-- Timelapse - replay logs
+DROP FUNCTION IF EXISTS api.timelapse_fn;
+CREATE OR REPLACE FUNCTION api.timelapse_fn(
+    IN start_log INTEGER DEFAULT NULL,
+    IN end_log INTEGER DEFAULT NULL,
+    IN start_date TEXT DEFAULT NULL,
+    IN end_date TEXT DEFAULT NULL,
+    OUT geojson JSONB) RETURNS JSONB AS $timelapse$
+    DECLARE
+        _geojson jsonb;
+    BEGIN
+        -- Using sub query to force id order by
+        -- Merge GIS track_geom into a GeoJSON MultiLineString
+        IF start_log IS NOT NULL AND public.isnumeric(start_log::text) AND public.isnumeric(end_log::text) THEN
+            WITH logbook as (
+                SELECT track_geom
+                    FROM api.logbook
+                    WHERE id >= start_log
+                        AND id <= end_log
+                        AND track_geom IS NOT NULL
+                    ORDER BY _from_time ASC
+                )
+            SELECT ST_AsGeoJSON(geo.*) INTO _geojson FROM (
+                    SELECT ST_Collect(
+                        ARRAY(
+                            SELECT track_geom FROM logbook))
+                ) as geo;
+            --raise WARNING 'by log id _geojson %' , _geojson;
+        ELSIF start_date IS NOT NULL AND public.isdate(start_date::text) AND public.isdate(end_date::text) THEN
+            WITH logbook as (
+                SELECT track_geom
+                    FROM api.logbook
+                    WHERE _from_time >= start_date::TIMESTAMPTZ
+                        AND _to_time <= end_date::TIMESTAMPTZ + interval '23 hours 59 minutes'
+                        AND track_geom IS NOT NULL
+                    ORDER BY _from_time ASC
+                )
+            SELECT ST_AsGeoJSON(geo.*) INTO _geojson FROM (
+                    SELECT ST_Collect(
+                        ARRAY(
+                            SELECT track_geom FROM logbook))
+                ) as geo;
+            --raise WARNING 'by date _geojson %' , _geojson;
+        ELSE
+            WITH logbook as (
+                SELECT track_geom
+                    FROM api.logbook
+                    WHERE track_geom IS NOT NULL
+                    ORDER BY _from_time ASC
+                )
+            SELECT ST_AsGeoJSON(geo.*) INTO _geojson FROM (
+                    SELECT ST_Collect(
+                        ARRAY(
+                            SELECT track_geom FROM logbook))
+                ) as geo;
+            --raise WARNING 'all result _geojson %' , _geojson;
+        END IF;
+        -- Return a GeoJSON MultiLineString
+        -- result _geojson [null, null]
+        --raise WARNING 'result _geojson %' , _geojson;
+        SELECT jsonb_build_object(
+            'type', 'FeatureCollection',
+            'features', ARRAY[_geojson] ) INTO geojson;
+    END;
+$timelapse$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.timelapse_fn
+    IS 'Export all selected logs geometry `track_geom` to a geojson as MultiLineString with empty properties';
+
+DROP FUNCTION IF EXISTS api.timelapse2_fn;
+CREATE OR REPLACE FUNCTION api.timelapse2_fn(
+    IN start_log INTEGER DEFAULT NULL,
+    IN end_log INTEGER DEFAULT NULL,
+    IN start_date TEXT DEFAULT NULL,
+    IN end_date TEXT DEFAULT NULL,
+    OUT geojson JSONB) RETURNS JSONB AS $timelapse2$
+    DECLARE
+        _geojson jsonb;
+    BEGIN
+        -- Using sub query to force id order by
+        -- Merge GIS track_geom into a GeoJSON Points
+        IF start_log IS NOT NULL AND public.isnumeric(start_log::text) AND public.isnumeric(end_log::text) THEN
+            SELECT jsonb_agg(
+                        jsonb_build_object('type', 'Feature',
+                                            'properties', jsonb_build_object( 'notes', f->'properties'->>'notes'),
+                                            'geometry', jsonb_build_object( 'coordinates', f->'geometry'->'coordinates', 'type', 'Point'))
+                    ) INTO _geojson
+            FROM (
+                SELECT jsonb_array_elements(track_geojson->'features') AS f
+                    FROM api.logbook
+                    WHERE id >= start_log
+                        AND id <= end_log
+                        AND track_geojson IS NOT NULL
+                    ORDER BY _from_time ASC
+            ) AS sub
+            WHERE (f->'geometry'->>'type') = 'Point';
+        ELSIF start_date IS NOT NULL AND public.isdate(start_date::text) AND public.isdate(end_date::text) THEN
+            SELECT jsonb_agg(
+                        jsonb_build_object('type', 'Feature',
+                                            'properties', jsonb_build_object( 'notes', f->'properties'->>'notes'),
+                                            'geometry', jsonb_build_object( 'coordinates', f->'geometry'->'coordinates', 'type', 'Point'))
+                    ) INTO _geojson
+            FROM (
+                SELECT jsonb_array_elements(track_geojson->'features') AS f
+                    FROM api.logbook
+                    WHERE _from_time >= start_date::TIMESTAMPTZ
+                        AND _to_time <= end_date::TIMESTAMPTZ + interval '23 hours 59 minutes'
+                        AND track_geojson IS NOT NULL
+                    ORDER BY _from_time ASC
+            ) AS sub
+            WHERE (f->'geometry'->>'type') = 'Point';
+        ELSE
+            SELECT jsonb_agg(
+                        jsonb_build_object('type', 'Feature',
+                                            'properties', jsonb_build_object( 'notes', f->'properties'->>'notes'),
+                                            'geometry', jsonb_build_object( 'coordinates', f->'geometry'->'coordinates', 'type', 'Point'))
+                    ) INTO _geojson
+            FROM (
+                SELECT jsonb_array_elements(track_geojson->'features') AS f
+                    FROM api.logbook
+                    WHERE track_geojson IS NOT NULL
+                    ORDER BY _from_time ASC
+            ) AS sub
+            WHERE (f->'geometry'->>'type') = 'Point';
+        END IF;
+        -- Return a GeoJSON MultiLineString
+        -- result _geojson [null, null]
+        raise WARNING 'result _geojson %' , _geojson;
+        SELECT jsonb_build_object(
+            'type', 'FeatureCollection',
+            'features', _geojson ) INTO geojson;
+    END;
+$timelapse2$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.timelapse2_fn
+    IS 'Export all selected logs geometry `track_geom` to a geojson as points with notes properties';
+
+-- export_logbook_geojson_fn
+DROP FUNCTION IF EXISTS api.export_logbook_geojson_fn;
+CREATE FUNCTION api.export_logbook_geojson_fn(IN _id integer, OUT geojson JSONB) RETURNS JSONB AS $export_logbook_geojson$
+-- validate with geojson.io
+    DECLARE
+        logbook_rec record;
+    BEGIN
+        -- If _id is is not NULL and > 0
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> export_logbook_geojson_fn invalid input %', _id;
+            RETURN;
+        END IF;
+        -- Gather log details
+        SELECT * INTO logbook_rec
+            FROM api.logbook WHERE id = _id;
+        -- Ensure the query is successful
+        IF logbook_rec.vessel_id IS NULL THEN
+            RAISE WARNING '-> export_logbook_geojson_fn invalid logbook %', _id;
+            RETURN;
+        END IF;
+        geojson := logbook_rec.track_geojson;
+    END;
+$export_logbook_geojson$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.export_logbook_geojson_fn
+    IS 'Export a log entry to geojson with features LineString and Point';
+
+-- Generate GPX XML file output
+-- https://opencpn.org/OpenCPN/info/gpxvalidation.html
+--
+DROP FUNCTION IF EXISTS api.export_logbook_gpx_fn;
+CREATE OR REPLACE FUNCTION api.export_logbook_gpx_fn(IN _id INTEGER) RETURNS "text/xml"
+AS $export_logbook_gpx$
+    DECLARE
+        app_settings jsonb;
+    BEGIN
+        -- If _id is is not NULL and > 0
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> export_logbook_gpx_fn invalid input %', _id;
+            RETURN '';
+        END IF;
+        -- Gather url from app settings
+        app_settings := get_app_url_fn();
+        --RAISE DEBUG '-> logbook_update_gpx_fn app_settings %', app_settings;
+        -- Generate GPX XML, extract Point features from geojson.
+        RETURN xmlelement(name gpx,
+                            xmlattributes(  '1.1' as version,
+                                            'PostgSAIL' as creator,
+                                            'http://www.topografix.com/GPX/1/1' as xmlns,
+                                            'http://www.opencpn.org' as "xmlns:opencpn",
+                                            app_settings->>'app.url' as "xmlns:postgsail",
+                                            'http://www.w3.org/2001/XMLSchema-instance' as "xmlns:xsi",
+                                            'http://www.garmin.com/xmlschemas/GpxExtensions/v3' as "xmlns:gpxx",
+                                            'http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd http://www.garmin.com/xmlschemas/GpxExtensions/v3 http://www8.garmin.com/xmlschemas/GpxExtensionsv3.xsd' as "xsi:schemaLocation"),
+                xmlelement(name metadata,
+                    xmlelement(name link, xmlattributes(app_settings->>'app.url' as href),
+                        xmlelement(name text, 'PostgSail'))),
+                xmlelement(name trk,
+                    xmlelement(name name, l.name),
+                    xmlelement(name desc, l.notes),
+                    xmlelement(name link, xmlattributes(concat(app_settings->>'app.url', '/log/', l.id) as href),
+                                                xmlelement(name text, l.name)),
+                    xmlelement(name extensions, xmlelement(name "postgsail:log_id", l.id),
+                                                xmlelement(name "postgsail:link", concat(app_settings->>'app.url', '/log/', l.id)),
+                                                xmlelement(name "opencpn:guid", uuid_generate_v4()),
+                                                xmlelement(name "opencpn:viz", '1'),
+                                                xmlelement(name "opencpn:start", l._from_time),
+                                                xmlelement(name "opencpn:end", l._to_time)
+                                                ),
+                    xmlelement(name trkseg, xmlagg(
+                                                xmlelement(name trkpt,
+                                                    xmlattributes(features->'geometry'->'coordinates'->1 as lat, features->'geometry'->'coordinates'->0 as lon),
+                                                        xmlelement(name time, features->'properties'->>'time')
+                                                )))))::pg_catalog.xml
+            FROM api.logbook l, jsonb_array_elements(track_geojson->'features') AS features
+            WHERE features->'geometry'->>'type' = 'Point'
+                AND l.id = _id
+            GROUP BY l.name,l.notes,l.id;
+          END;
+$export_logbook_gpx$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.export_logbook_gpx_fn
+    IS 'Export a log entry to GPX XML format';
+
+-- Generate KML XML file output
+-- https://developers.google.com/kml/documentation/kml_tut
+-- TODO https://developers.google.com/kml/documentation/time#timespans
+DROP FUNCTION IF EXISTS api.export_logbook_kml_fn;
+CREATE OR REPLACE FUNCTION api.export_logbook_kml_fn(IN _id INTEGER) RETURNS "text/xml"
+AS $export_logbook_kml$
+    DECLARE
+        logbook_rec record;
+    BEGIN
+        -- If _id is is not NULL and > 0
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> export_logbook_kml_fn invalid input %', _id;
+            return '';
+        END IF;
+        -- Gather log details
+        SELECT * INTO logbook_rec
+            FROM api.logbook WHERE id = _id;
+        -- Ensure the query is successful
+        IF logbook_rec.vessel_id IS NULL THEN
+            RAISE WARNING '-> export_logbook_kml_fn invalid logbook %', _id;
+            return '';
+        END IF;
+        -- Extract POINT from LINESTRING to generate KML XML
+        RETURN xmlelement(name kml,
+                                xmlattributes(  '1.0' as version,
+                                                'PostgSAIL' as creator,
+                                                'http://www.w3.org/2005/Atom' as "xmlns:atom",
+                                                'http://www.opengis.net/kml/2.2' as "xmlns",
+                                                'http://www.google.com/kml/ext/2.2' as "xmlns:gx",
+                                                'http://www.opengis.net/kml/2.2' as "xmlns:kml"),
+                                xmlelement(name "Document",
+                                                xmlelement(name name, logbook_rec.name),
+                                                xmlelement(name "Placemark",
+                                                    xmlelement(name name, logbook_rec.notes),
+                                                    ST_AsKML(logbook_rec.track_geom)::pg_catalog.xml)
+                            ))::pg_catalog.xml
+               FROM api.logbook WHERE id = _id;
+    END;
+$export_logbook_kml$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.export_logbook_kml_fn
+    IS 'Export a log entry to KML XML format';
+
+DROP FUNCTION IF EXISTS api.export_logbooks_gpx_fn;
+CREATE OR REPLACE FUNCTION api.export_logbooks_gpx_fn(
+    IN start_log INTEGER DEFAULT NULL,
+    IN end_log INTEGER DEFAULT NULL) RETURNS "application/gpx+xml"
+AS $export_logbooks_gpx$
+    declare
+        merged_jsonb jsonb;
+        app_settings jsonb;
+    BEGIN
+        -- Merge GIS track_geom of geometry type Point into a jsonb array format
+        IF start_log IS NOT NULL AND public.isnumeric(start_log::text) AND public.isnumeric(end_log::text) THEN
+            SELECT jsonb_agg(
+                        jsonb_build_object('coordinates', f->'geometry'->'coordinates', 'time', f->'properties'->>'time')
+                    ) INTO merged_jsonb
+            FROM (
+                SELECT jsonb_array_elements(track_geojson->'features') AS f
+                    FROM api.logbook
+                    WHERE id >= start_log
+                        AND id <= end_log
+                        AND track_geojson IS NOT NULL
+                    ORDER BY _from_time ASC
+            ) AS sub
+            WHERE (f->'geometry'->>'type') = 'Point';
+        ELSE
+            SELECT jsonb_agg(
+                        jsonb_build_object('coordinates', f->'geometry'->'coordinates', 'time', f->'properties'->>'time')
+                    ) INTO merged_jsonb
+            FROM (
+                SELECT jsonb_array_elements(track_geojson->'features') AS f
+                    FROM api.logbook
+                    WHERE track_geojson IS NOT NULL
+                    ORDER BY _from_time ASC
+            ) AS sub
+            WHERE (f->'geometry'->>'type') = 'Point';
+        END IF;
+        --RAISE WARNING '-> export_logbooks_gpx_fn _jsonb %' , _jsonb;
+        -- Gather url from app settings
+        app_settings := get_app_url_fn();
+        --RAISE WARNING '-> export_logbooks_gpx_fn app_settings %', app_settings;
+        -- Generate GPX XML, extract Point features from geojson.
+        RETURN xmlelement(name gpx,
+                            xmlattributes(  '1.1' as version,
+                                            'PostgSAIL' as creator,
+                                            'http://www.topografix.com/GPX/1/1' as xmlns,
+                                            'http://www.opencpn.org' as "xmlns:opencpn",
+                                            app_settings->>'app.url' as "xmlns:postgsail"),
+                xmlelement(name metadata,
+                    xmlelement(name link, xmlattributes(app_settings->>'app.url' as href),
+                        xmlelement(name text, 'PostgSail'))),
+                xmlelement(name trk,
+                    xmlelement(name name, 'logbook name'),
+                    xmlelement(name trkseg, xmlagg(
+                                                xmlelement(name trkpt,
+                                                    xmlattributes(features->'coordinates'->1 as lat, features->'coordinates'->0 as lon),
+                                                        xmlelement(name time, features->'properties'->>'time')
+                                                )))))::pg_catalog.xml
+            FROM jsonb_array_elements(merged_jsonb) AS features;
+    END;
+$export_logbooks_gpx$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.export_logbooks_gpx_fn
+    IS 'Export a logs entries to GPX XML format';
+
+DROP FUNCTION IF EXISTS api.export_logbooks_kml_fn;
+CREATE OR REPLACE FUNCTION api.export_logbooks_kml_fn(
+    IN start_log INTEGER DEFAULT NULL,
+    IN end_log INTEGER DEFAULT NULL) RETURNS "text/xml"
+AS $export_logbooks_kml$
+DECLARE
+    _geom geometry;
+    app_settings jsonb;
+BEGIN
+    -- Merge GIS track_geom into a GeoJSON MultiLineString
+    IF start_log IS NOT NULL AND public.isnumeric(start_log::text) AND public.isnumeric(end_log::text) THEN
+        WITH logbook as (
+            SELECT track_geom
+            FROM api.logbook
+            WHERE id >= start_log
+                AND id <= end_log
+                AND track_geom IS NOT NULL
+            ORDER BY _from_time ASC
+        )
+        SELECT ST_Collect(
+                    ARRAY(
+                        SELECT track_geom FROM logbook))
+         into _geom;
+    ELSE
+        WITH logbook as (
+            SELECT track_geom
+            FROM api.logbook
+            WHERE track_geom IS NOT NULL
+            ORDER BY _from_time ASC
+        )
+        SELECT ST_Collect(
+                    ARRAY(
+                        SELECT track_geom FROM logbook))
+         into _geom;
+        --raise WARNING 'all result _geojson %' , _geojson;
+    END IF;
+
+    -- Extract POINT from LINESTRING to generate KML XML
+    RETURN xmlelement(name kml,
+            xmlattributes(  '1.0' as version,
+                            'PostgSAIL' as creator,
+                            'http://www.w3.org/2005/Atom' as "xmlns:atom",
+                            'http://www.opengis.net/kml/2.2' as "xmlns",
+                            'http://www.google.com/kml/ext/2.2' as "xmlns:gx",
+                            'http://www.opengis.net/kml/2.2' as "xmlns:kml"),
+            xmlelement(name "Document",
+                xmlelement(name name, 'logbook name'),
+                xmlelement(name "Placemark",
+                    ST_AsKML(_geom)::pg_catalog.xml
+                )
+            )
+        )::pg_catalog.xml;
+END;
+$export_logbooks_kml$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.export_logbooks_kml_fn
+    IS 'Export a logs entries to KML XML format';
+
+-- Find all log from and to moorage geopoint within 100m
+DROP FUNCTION IF EXISTS api.find_log_from_moorage_fn;
+CREATE OR REPLACE FUNCTION api.find_log_from_moorage_fn(IN _id INTEGER, OUT geojson JSONB) RETURNS JSONB AS $find_log_from_moorage$
+    DECLARE
+        moorage_rec record;
+        _geojson jsonb;
+    BEGIN
+        -- If _id is is not NULL and > 0
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> find_log_from_moorage_fn invalid input %', _id;
+            RETURN;
+        END IF;
+        -- Gather moorage details
+        SELECT * INTO moorage_rec
+            FROM api.moorages m
+            WHERE m.id = _id;
+        -- Find all log from and to moorage geopoint within 100m
+        SELECT jsonb_agg(l.track_geojson->'features') INTO _geojson
+            FROM api.logbook l
+            WHERE ST_DWithin(
+                    Geography(ST_MakePoint(l._from_lng, l._from_lat)),
+                    moorage_rec.geog,
+                    1000 -- in meters ?
+                );
+        -- Return a GeoJSON filter on LineString
+        SELECT jsonb_build_object(
+            'type', 'FeatureCollection',
+            'features', public.geojson_py_fn(_geojson, 'Point'::TEXT) ) INTO geojson;
+    END;
+$find_log_from_moorage$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.find_log_from_moorage_fn
+    IS 'Find all log from moorage geopoint within 100m';
+
+DROP FUNCTION IF EXISTS api.find_log_to_moorage_fn;
+CREATE OR REPLACE FUNCTION api.find_log_to_moorage_fn(IN _id INTEGER, OUT geojson JSONB) RETURNS JSONB AS $find_log_to_moorage$
+    DECLARE
+        moorage_rec record;
+        _geojson jsonb;
+    BEGIN
+        -- If _id is is not NULL and > 0
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> find_log_from_moorage_fn invalid input %', _id;
+            RETURN;
+        END IF;
+        -- Gather moorage details
+        SELECT * INTO moorage_rec
+            FROM api.moorages m
+            WHERE m.id = _id;
+        -- Find all log from and to moorage geopoint within 100m
+        SELECT jsonb_agg(l.track_geojson->'features') INTO _geojson
+            FROM api.logbook l
+            WHERE ST_DWithin(
+                    Geography(ST_MakePoint(l._to_lng, l._to_lat)),
+                    moorage_rec.geog,
+                    1000 -- in meters ?
+                );
+        -- Return a GeoJSON filter on LineString
+        SELECT jsonb_build_object(
+            'type', 'FeatureCollection',
+            'features', public.geojson_py_fn(_geojson, 'Point'::TEXT) ) INTO geojson;
+    END;
+$find_log_to_moorage$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.find_log_to_moorage_fn
+    IS 'Find all log to moorage geopoint within 100m';
+
+-- Find all stay within 100m of moorage geopoint
+DROP FUNCTION IF EXISTS api.find_stay_from_moorage_fn;
+CREATE OR REPLACE FUNCTION api.find_stay_from_moorage_fn(IN _id INTEGER) RETURNS void AS $find_stay_from_moorage$
+    DECLARE
+        moorage_rec record;
+        stay_rec record;
+    BEGIN
+        -- If _id is is not NULL and > 0
+        SELECT * INTO moorage_rec
+            FROM api.moorages m 
+            WHERE m.id = _id;
+        -- find all log from and to moorage geopoint within 100m
+        --RETURN QUERY
+            SELECT s.id,s.arrived,s.departed,s.duration,sa.description
+                FROM api.stays s, api.stays_at sa
+                WHERE ST_DWithin(
+                        s.geog,
+                        moorage_rec.geog,
+                        100 -- in meters ?
+                    )
+                    AND departed IS NOT NULL
+                    AND s.name IS NOT NULL
+                    AND s.stay_code = sa.stay_code
+                ORDER BY s.arrived DESC;
+    END;
+$find_stay_from_moorage$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.find_stay_from_moorage_fn
+    IS 'Find all stay within 100m of moorage geopoint';
+
+-- trip_in_progress_fn
+DROP FUNCTION IF EXISTS public.trip_in_progress_fn;
+CREATE FUNCTION public.trip_in_progress_fn(IN _vessel_id TEXT) RETURNS INT AS $trip_in_progress$
+    DECLARE
+        logbook_id INT := NULL;
+    BEGIN
+        SELECT id INTO logbook_id
+            FROM api.logbook l
+            WHERE l.vessel_id IS NOT NULL
+                AND l.vessel_id = _vessel_id
+                AND active IS true
+            LIMIT 1;
+        RETURN logbook_id;
+    END;
+$trip_in_progress$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.trip_in_progress_fn
+    IS 'trip_in_progress';
+
+-- stay_in_progress_fn
+DROP FUNCTION IF EXISTS public.stay_in_progress_fn;
+CREATE FUNCTION public.stay_in_progress_fn(IN _vessel_id TEXT) RETURNS INT AS $stay_in_progress$
+    DECLARE
+        stay_id INT := NULL;
+    BEGIN
+        SELECT id INTO stay_id
+                FROM api.stays s
+                WHERE s.vessel_id IS NOT NULL
+                    AND s.vessel_id = _vessel_id
+                    AND active IS true
+                LIMIT 1;
+        RETURN stay_id;
+    END;
+$stay_in_progress$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.stay_in_progress_fn
+    IS 'stay_in_progress';
+
+-- logs_by_month_fn
+DROP FUNCTION IF EXISTS api.logs_by_month_fn;
+CREATE FUNCTION api.logs_by_month_fn(OUT charts JSONB) RETURNS JSONB AS $logs_by_month$
+    DECLARE
+        data JSONB;
+    BEGIN
+        -- Query logs by month
+        SELECT json_object_agg(month,count) INTO data
+            FROM (
+                    SELECT
+                        to_char(date_trunc('month', _from_time), 'MM') as month,
+                        count(*) as count
+                        FROM api.logbook
+                        GROUP BY month
+                        ORDER BY month
+                ) AS t;
+        -- Merge jsonb to get all 12 months
+        SELECT '{"01": 0, "02": 0, "03": 0, "04": 0, "05": 0, "06": 0, "07": 0, "08": 0, "09": 0, "10": 0, "11": 0,"12": 0}'::jsonb ||
+            data::jsonb INTO charts;
+    END;
+$logs_by_month$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.logs_by_month_fn
+    IS 'logbook by month for web charts';
+
+-- logs_by_day_fn
+DROP FUNCTION IF EXISTS api.logs_by_day_fn;
+CREATE FUNCTION api.logs_by_day_fn(OUT charts JSONB) RETURNS JSONB AS $logs_by_day$
+    DECLARE
+        data JSONB;
+    BEGIN
+        -- Query logs by day
+        SELECT json_object_agg(day,count) INTO data
+            FROM (
+                    SELECT
+                        to_char(date_trunc('day', _from_time), 'D') as day,
+                        count(*) as count
+                        FROM api.logbook
+                        GROUP BY day
+                        ORDER BY day
+                ) AS t;
+        -- Merge jsonb to get all 7 days
+        SELECT '{"01": 0, "02": 0, "03": 0, "04": 0, "05": 0, "06": 0, "07": 0}'::jsonb ||
+            data::jsonb INTO charts;
+    END;
+$logs_by_day$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.logs_by_day_fn
+    IS 'logbook by day for web charts';
+
+-- moorage_geojson_fn
+DROP FUNCTION IF EXISTS api.export_moorages_geojson_fn;
+CREATE FUNCTION api.export_moorages_geojson_fn(OUT geojson JSONB) RETURNS JSONB AS $export_moorages_geojson$
+    DECLARE
+    BEGIN
+        SELECT jsonb_build_object(
+            'type', 'FeatureCollection',
+            'features',
+                ( SELECT
+                    json_agg(ST_AsGeoJSON(m.*)::JSON) as moorages_geojson
+                    FROM
+                    ( SELECT
+                        id,name,stay_code,
+                        EXTRACT(DAY FROM justify_hours ( stay_duration )) AS Total_Stay,
+                        geog
+                        FROM api.moorages
+                        WHERE geog IS NOT NULL
+                    ) AS m
+                )
+            ) INTO geojson;
+    END;
+$export_moorages_geojson$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.export_moorages_geojson_fn
+    IS 'Export moorages as geojson';
+
+DROP FUNCTION IF EXISTS api.export_moorages_gpx_fn;
+CREATE FUNCTION api.export_moorages_gpx_fn() RETURNS "text/xml" AS $export_moorages_gpx$
+    DECLARE
+        app_settings jsonb;
+    BEGIN
+        -- Gather url from app settings
+        app_settings := get_app_url_fn();
+        -- Generate XML
+        RETURN xmlelement(name gpx,
+                    xmlattributes(  '1.1' as version,
+                                    'PostgSAIL' as creator,
+                                    'http://www.topografix.com/GPX/1/1' as xmlns,
+                                    'http://www.opencpn.org' as "xmlns:opencpn",
+                                    app_settings->>'app.url' as "xmlns:postgsail",
+                                    'http://www.w3.org/2001/XMLSchema-instance' as "xmlns:xsi",
+                                    'http://www.garmin.com/xmlschemas/GpxExtensions/v3' as "xmlns:gpxx",
+                                    'http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd http://www.garmin.com/xmlschemas/GpxExtensions/v3 http://www8.garmin.com/xmlschemas/GpxExtensionsv3.xsd' as "xsi:schemaLocation"),
+                    xmlagg(
+                        xmlelement(name wpt, xmlattributes(m.latitude as lat, m.longitude as lon),
+                            xmlelement(name name, m.name),
+                            xmlelement(name time, 'TODO first seen'),
+                            xmlelement(name desc,
+                                concat('Last Stayed On: ', 'TODO last seen',
+                                    E'\nTotal Stays: ', m.stay_duration,
+                                    E'\nTotal Arrivals and Departures: ', m.reference_count,
+                                    E'\nLink: ', concat(app_settings->>'app.url','/moorage/', m.id)),
+                                    xmlelement(name "opencpn:guid", uuid_generate_v4())),
+                            xmlelement(name sym, 'anchor'),
+                            xmlelement(name type, 'WPT'),
+                            xmlelement(name link, xmlattributes(concat(app_settings->>'app.url','moorage/', m.id) as href),
+                                                        xmlelement(name text, m.name)),
+                            xmlelement(name extensions, xmlelement(name "postgsail:mooorage_id", m.id),
+                                                        xmlelement(name "postgsail:link", concat(app_settings->>'app.url','/moorage/', m.id)),
+                                                        xmlelement(name "opencpn:guid", uuid_generate_v4()),
+                                                        xmlelement(name "opencpn:viz", '1'),
+                                                        xmlelement(name "opencpn:scale_min_max", xmlattributes(true as UseScale, 30000 as ScaleMin, 0 as ScaleMax)
+                                                        ))))
+                    )::pg_catalog.xml
+            FROM api.moorages m
+            WHERE geog IS NOT NULL;
+    END;
+$export_moorages_gpx$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.export_moorages_gpx_fn
+    IS 'Export moorages as gpx';
+
+----------------------------------------------------------------------------------------------
+-- Statistics
+DROP FUNCTION IF EXISTS api.stats_logs_fn;
+CREATE OR REPLACE FUNCTION api.stats_logs_fn(
+    IN start_date TEXT DEFAULT NULL,
+    IN end_date TEXT DEFAULT NULL,
+    OUT stats JSONB) RETURNS JSONB AS $stats_logs$
+    DECLARE
+        _start_date TIMESTAMPTZ DEFAULT '1970-01-01';
+        _end_date TIMESTAMPTZ DEFAULT NOW();
+    BEGIN
+        IF start_date IS NOT NULL AND public.isdate(start_date::text) AND public.isdate(end_date::text) THEN
+            RAISE WARNING '--> stats_fn, filter result stats by date [%]', start_date;
+            _start_date := start_date::TIMESTAMPTZ;
+            _end_date := end_date::TIMESTAMPTZ;
+        END IF;
+        RAISE NOTICE '--> stats_fn, _start_date [%], _end_date [%]', _start_date, _end_date;
+        WITH
+            meta AS (
+                SELECT m.name FROM api.metadata m ),
+            logs_view AS (
+                SELECT *
+                    FROM api.logbook l
+                    WHERE _from_time >= _start_date::TIMESTAMPTZ
+                        AND _to_time <= _end_date::TIMESTAMPTZ + interval '23 hours 59 minutes'
+                ),
+            first_date AS (
+                SELECT _from_time as first_date from logs_view ORDER BY first_date ASC LIMIT 1
+            ),
+            last_date AS (
+                SELECT _to_time as last_date from logs_view ORDER BY _to_time DESC LIMIT 1
+            ),
+            max_speed_id AS (
+                SELECT id FROM logs_view WHERE max_speed = (SELECT max(max_speed) FROM logs_view) ),
+            max_wind_speed_id AS (
+                SELECT id FROM logs_view WHERE max_wind_speed = (SELECT max(max_wind_speed) FROM logs_view)),
+            max_distance_id AS (
+                SELECT id FROM logs_view WHERE distance = (SELECT max(distance) FROM logs_view)),
+            max_duration_id AS (
+                SELECT id FROM logs_view WHERE duration = (SELECT max(duration) FROM logs_view)),
+            logs_stats AS (
+                SELECT
+                    count(*) AS count,
+                    max(max_speed) AS max_speed,
+                    max(max_wind_speed) AS max_wind_speed,
+                    max(distance) AS max_distance,
+                    sum(distance) AS sum_distance,
+                    max(duration) AS max_duration,
+                    sum(duration) AS sum_duration
+                FROM logs_view l )
+              --select * from logbook;
+        -- Return a JSON
+        SELECT jsonb_build_object(
+            'name', meta.name,
+            'first_date', first_date.first_date,
+            'last_date', last_date.last_date,
+            'max_speed_id', max_speed_id.id,
+            'max_wind_speed_id', max_wind_speed_id.id,
+            'max_duration_id', max_duration_id.id,
+            'max_distance_id', max_distance_id.id)::jsonb || to_jsonb(logs_stats.*)::jsonb INTO stats
+            FROM max_speed_id, max_wind_speed_id, max_distance_id, max_duration_id,
+                logs_stats, meta, logs_view, first_date, last_date;
+        -- TODO Add moorages
+    END;
+$stats_logs$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.stats_logs_fn
+    IS 'Logs stats by date';
+
+DROP FUNCTION IF EXISTS api.stats_stays_fn;
+CREATE OR REPLACE FUNCTION api.stats_stays_fn(
+    IN start_date TEXT DEFAULT NULL,
+    IN end_date TEXT DEFAULT NULL,
+    OUT stats JSON) RETURNS JSON AS $stats_stays$
+    DECLARE
+        _start_date TIMESTAMPTZ DEFAULT '1970-01-01';
+        _end_date TIMESTAMPTZ DEFAULT NOW();
+    BEGIN
+        IF start_date IS NOT NULL AND public.isdate(start_date::text) AND public.isdate(end_date::text) THEN
+            RAISE NOTICE '--> stats_stays_fn, custom filter result stats by date [%]', start_date;
+            _start_date := start_date::TIMESTAMPTZ;
+            _end_date := end_date::TIMESTAMPTZ;
+        END IF;
+        RAISE NOTICE '--> stats_stays_fn, _start_date [%], _end_date [%]', _start_date, _end_date;
+        WITH
+            moorages_log AS (
+                SELECT s.id as stays_id, m.id as moorages_id, *
+                    FROM api.stays s, api.moorages m
+                    WHERE arrived >= _start_date::TIMESTAMPTZ
+                        AND departed <= _end_date::TIMESTAMPTZ + interval '23 hours 59 minutes'
+                        AND s.id = m.stay_id
+                ),
+	        home_ports AS (
+	            select count(*) as home_ports from moorages_log m where home_flag is true
+	        ),
+	        unique_moorage AS (
+	            select count(*) as unique_moorage from moorages_log m
+	        ),
+	        time_at_home_ports AS (
+	            select sum(m.stay_duration) as time_at_home_ports from moorages_log m where home_flag is true
+	        ),
+	        sum_stay_duration AS (
+	            select sum(m.stay_duration) as sum_stay_duration from moorages_log m where home_flag is false
+            ),
+            time_spent_away AS (
+                select m.stay_code,sum(m.stay_duration) as stay_duration from api.moorages m where home_flag is false group by m.stay_code order by m.stay_code
+            ),
+            time_spent as (
+                select jsonb_agg(t.*) as time_spent_away from time_spent_away t
+            )
+        -- Return a JSON
+        SELECT jsonb_build_object(
+            'home_ports', home_ports.home_ports,
+            'unique_moorage', unique_moorage.unique_moorage,
+            'time_at_home_ports', time_at_home_ports.time_at_home_ports,
+            'sum_stay_duration', sum_stay_duration.sum_stay_duration,
+            'time_spent_away', time_spent.time_spent_away) INTO stats
+            FROM moorages_log, home_ports, unique_moorage,
+                        time_at_home_ports, sum_stay_duration, time_spent;
+        -- TODO Add moorages
+    END;
+$stats_stays$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.stats_stays_fn
+    IS 'Stays/Moorages stats by date';
+
+DROP FUNCTION IF EXISTS api.delete_logbook_fn;
+CREATE OR REPLACE FUNCTION api.delete_logbook_fn(IN _id integer) RETURNS BOOLEAN AS $delete_logbook$
+    DECLARE
+        logbook_rec record;
+        previous_stays_id numeric;
+        current_stays_departed text;
+        current_stays_id numeric;
+        current_stays_active boolean;
+       BEGIN
+        -- If _id is not NULL
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> delete_logbook_fn invalid input %', _id;
+            RETURN FALSE;
+        END IF;
+        SELECT * INTO logbook_rec
+            FROM api.logbook l
+            WHERE id = _id;
+        -- Update logbook
+        UPDATE api.logbook l
+            SET notes = 'mark for deletion'
+            WHERE l.vessel_id = current_setting('vessel.id', false)
+                AND id = logbook_rec.id;
+        -- Update metrics status to moored
+        UPDATE api.metrics
+            SET status = 'moored'
+            WHERE time >= logbook_rec._from_time::TIMESTAMPTZ
+                AND time <= logbook_rec._to_time::TIMESTAMPTZ
+                AND vessel_id = current_setting('vessel.id', false);
+        -- Get related stays
+        SELECT id,departed,active INTO current_stays_id,current_stays_departed,current_stays_active
+            FROM api.stays s
+            WHERE s.vessel_id = current_setting('vessel.id', false)
+                AND s.arrived = logbook_rec._to_time;
+        -- Update related stays
+        UPDATE api.stays s
+            SET notes = 'mark for deletion'
+            WHERE s.vessel_id = current_setting('vessel.id', false)
+                AND s.arrived = logbook_rec._to_time;
+        -- Find previous stays
+        SELECT id INTO previous_stays_id
+            FROM api.stays s
+            WHERE s.vessel_id = current_setting('vessel.id', false)
+                AND s.arrived < logbook_rec._to_time
+                ORDER BY s.arrived DESC LIMIT 1;
+        -- Update previous stays with the departed time from current stays
+        --  and set the active state from current stays
+        UPDATE api.stays
+            SET departed = current_stays_departed::TIMESTAMPTZ,
+                active = current_stays_active
+            WHERE vessel_id = current_setting('vessel.id', false)
+                AND id = previous_stays_id;
+        -- Clean up, remove invalid logbook and stay entry
+        DELETE FROM api.logbook WHERE id = logbook_rec.id;
+        RAISE WARNING '-> delete_logbook_fn delete logbook [%]', logbook_rec.id;
+        DELETE FROM api.stays WHERE id = current_stays_id;
+        RAISE WARNING '-> delete_logbook_fn delete stays [%]', current_stays_id;
+        -- Clean up, Subtract (-1) moorages ref count
+        UPDATE api.moorages
+            SET reference_count = reference_count - 1
+            WHERE vessel_id = current_setting('vessel.id', false)
+                AND id = previous_stays_id;
+        RETURN TRUE;
+    END;
+$delete_logbook$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.delete_logbook_fn
+    IS 'Delete a logbook and dependency stay';
+
+CREATE OR REPLACE FUNCTION api.monitoring_history_fn(IN time_interval TEXT DEFAULT '24', OUT history_metrics JSONB) RETURNS JSONB AS $monitoring_history$
+    DECLARE
+        bucket_interval interval := '5 minutes';
+    BEGIN
+        RAISE NOTICE '-> monitoring_history_fn';
+        SELECT CASE time_interval
+            WHEN '24' THEN '5 minutes'
+            WHEN '48' THEN '2 hours'
+            WHEN '72' THEN '4 hours'
+            WHEN '168' THEN '7 hours'
+            ELSE '5 minutes'
+            END bucket INTO bucket_interval;
+        RAISE NOTICE '-> monitoring_history_fn % %', time_interval, bucket_interval;
+        WITH history_table AS (
+            SELECT time_bucket(bucket_interval::INTERVAL, time) AS time_bucket,
+                avg((metrics->'environment.water.temperature')::numeric) AS waterTemperature,
+                avg((metrics->'environment.inside.temperature')::numeric) AS insideTemperature,
+                avg((metrics->'environment.outside.temperature')::numeric) AS outsideTemperature,
+                avg((metrics->'environment.wind.speedOverGround')::numeric) AS windSpeedOverGround,
+                avg((metrics->'environment.inside.relativeHumidity')::numeric) AS insideHumidity,
+                avg((metrics->'environment.outside.relativeHumidity')::numeric) AS outsideHumidity,
+                avg((metrics->'environment.outside.pressure')::numeric) AS outsidePressure,
+                avg((metrics->'environment.inside.pressure')::numeric) AS insidePressure,
+                avg((metrics->'electrical.batteries.House.capacity.stateOfCharge')::numeric) AS batteryCharge,
+                avg((metrics->'electrical.batteries.House.voltage')::numeric) AS batteryVoltage,
+                avg((metrics->'environment.depth.belowTransducer')::numeric) AS depth
+                FROM api.metrics
+                WHERE time > (NOW() AT TIME ZONE 'UTC' - INTERVAL '1 hours' * time_interval::NUMERIC)
+                GROUP BY time_bucket
+                ORDER BY time_bucket asc
+        )
+        SELECT jsonb_agg(history_table) INTO history_metrics FROM history_table;
+    END
+$monitoring_history$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.monitoring_history_fn
+    IS 'Export metrics from a time period 24h, 48h, 72h, 7d';
+
+CREATE OR REPLACE FUNCTION api.status_fn(out status jsonb) RETURNS JSONB AS $status_fn$
+    DECLARE
+        in_route BOOLEAN := False;
+    BEGIN
+        RAISE NOTICE '-> status_fn';
+        SELECT EXISTS ( SELECT id
+                        FROM api.logbook l
+                        WHERE active IS True
+                        LIMIT 1
+                    ) INTO in_route;
+        IF in_route IS True THEN
+            -- In route from <logbook.from_name> arrived at <>
+            SELECT jsonb_build_object('status', sa.description, 'location', m.name, 'departed', l._from_time) INTO status
+                from api.logbook l, api.stays_at sa, api.moorages m
+                where s.stay_code = sa.stay_code AND l._from_moorage_id = m.id AND l.active IS True;
+        ELSE
+            -- At <Stat_at.Desc> in <Moorage.name> departed at <>
+            SELECT jsonb_build_object('status', sa.description, 'location', m.name, 'arrived', s.arrived) INTO status
+                from api.stays s, api.stays_at sa, api.moorages m
+                where s.stay_code = sa.stay_code AND s.moorage_id = m.id AND s.active IS True;
+        END IF;
+    END
+$status_fn$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.status_fn
+    IS 'generate vessel status';

initdb/02_1_3_signalk_api_views.sql

@@ -0,0 +1,510 @@
+
+-- connect to the DB
+\c signalk
+
+---------------------------------------------------------------------------
+-- API helper views
+--
+---------------------------------------------------------------------------
+
+---------------------------------------------------------------------------
+-- Views
+-- Views are invoked with the privileges of the view owner,
+-- make the user_role the view’s owner.
+-- to bypass this limit you need pg15+ with specific settings
+-- security_invoker=true,security_barrier=true
+---------------------------------------------------------------------------
+
+CREATE VIEW public.first_metric AS
+    SELECT * 
+        FROM api.metrics
+        ORDER BY time ASC LIMIT 1;
+
+CREATE VIEW public.last_metric AS
+    SELECT * 
+        FROM api.metrics
+        ORDER BY time DESC LIMIT 1;
+
+DROP VIEW IF EXISTS public.trip_in_progress;
+CREATE VIEW public.trip_in_progress AS
+    SELECT * 
+        FROM api.logbook 
+        WHERE active IS true;
+
+DROP VIEW IF EXISTS public.stay_in_progress;
+CREATE VIEW public.stay_in_progress AS
+    SELECT * 
+        FROM api.stays 
+        WHERE active IS true;
+
+-- TODO: Use materialized views instead as it is not live data
+-- Logs web view
+DROP VIEW IF EXISTS api.logs_view;
+CREATE OR REPLACE VIEW api.logs_view WITH (security_invoker=true,security_barrier=true) AS
+    SELECT id,
+            name as "name",
+            _from as "from",
+            _from_time as "started",
+            _to as "to",
+            _to_time as "ended",
+            distance as "distance",
+            duration as "duration",
+            _from_moorage_id,_to_moorage_id
+        FROM api.logbook l
+        WHERE name IS NOT NULL
+            AND _to_time IS NOT NULL
+        ORDER BY _from_time DESC;
+-- Description
+COMMENT ON VIEW
+    api.logs_view
+    IS 'Logs web view';
+
+-- Initial try of MATERIALIZED VIEW - does not support RLS
+CREATE MATERIALIZED VIEW api.logs_mat_view AS
+    SELECT id,
+            name as "name",
+            _from as "from",
+            _from_time as "started",
+            _to as "to",
+            _to_time as "ended",
+            distance as "distance",
+            duration as "duration",
+            _from_moorage_id,_to_moorage_id
+        FROM api.logbook l
+        WHERE name IS NOT NULL
+            AND _to_time IS NOT NULL
+        ORDER BY _from_time DESC;
+-- Description
+COMMENT ON MATERIALIZED VIEW
+    api.logs_mat_view
+    IS 'Logs MATERIALIZED web view';
+
+DROP VIEW IF EXISTS api.log_view;
+CREATE OR REPLACE VIEW api.log_view WITH (security_invoker=true,security_barrier=true) AS
+    SELECT id,
+            name as "name",
+            _from as "from",
+            _from_time as "started",
+            _to as "to",
+            _to_time as "ended",
+            distance as "distance",
+            duration as "duration",
+            notes as "notes",
+            track_geojson as geojson,
+            avg_speed as avg_speed,
+            max_speed as max_speed,
+            max_wind_speed as max_wind_speed,
+            extra as extra,
+            _from_moorage_id as from_moorage_id,
+            _to_moorage_id as to_moorage_id
+        FROM api.logbook l
+        WHERE _to_time IS NOT NULL
+        ORDER BY _from_time DESC;
+-- Description
+COMMENT ON VIEW
+    api.log_view
+    IS 'Log web view';
+
+-- Stays web view
+DROP VIEW IF EXISTS api.stays_view;
+CREATE OR REPLACE VIEW api.stays_view WITH (security_invoker=true,security_barrier=true) AS
+    SELECT s.id,
+        s.name AS "name",
+        m.name AS "moorage",
+        m.id AS "moorage_id",
+        (s.departed-s.arrived) AS "duration",
+        sa.description AS "stayed_at",
+        sa.stay_code AS "stayed_at_id",
+        s.arrived AS "arrived",
+        _from.id as "arrived_log_id",
+        _from._to_moorage_id as "arrived_from_moorage_id",
+        _from._to as "arrived_from_moorage_name",
+        s.departed AS "departed",
+        _to.id AS "departed_log_id",
+        _to._from_moorage_id AS "departed_to_moorage_id",
+        _to._from AS "departed_to_moorage_name",
+        s.notes AS "notes"
+    FROM api.stays_at sa, api.moorages m, api.stays s
+    LEFT JOIN api.logbook AS _from ON _from._from_time = s.departed
+    LEFT JOIN api.logbook AS _to ON _to._to_time = s.arrived
+    WHERE s.departed IS NOT NULL
+        AND _from._to_moorage_id IS NOT NULL
+        AND s.name IS NOT NULL
+        AND s.stay_code = sa.stay_code
+        AND s.moorage_id = m.id
+    ORDER BY s.arrived DESC;
+-- Description
+COMMENT ON VIEW
+    api.stays_view
+    IS 'Stays web view';
+
+DROP VIEW IF EXISTS api.stay_view;
+CREATE OR REPLACE VIEW api.stay_view WITH (security_invoker=true,security_barrier=true) AS
+    SELECT s.id,
+        s.name AS "name",
+        m.name AS "moorage",
+        m.id AS "moorage_id",
+        (s.departed-s.arrived) AS "duration",
+        sa.description AS "stayed_at",
+        sa.stay_code AS "stayed_at_id",
+        s.arrived AS "arrived",
+        _from.id as "arrived_log_id",
+        _from._to_moorage_id as "arrived_from_moorage_id",
+        _from._to as "arrived_from_moorage_name",
+        s.departed AS "departed",
+        _to.id AS "departed_log_id",
+        _to._from_moorage_id AS "departed_to_moorage_id",
+        _to._from AS "departed_to_moorage_name",
+        s.notes AS "notes"
+    FROM api.stays_at sa, api.moorages m, api.stays s
+    LEFT JOIN api.logbook AS _from ON _from._from_time = s.departed
+    LEFT JOIN api.logbook AS _to ON _to._to_time = s.arrived
+    WHERE s.departed IS NOT NULL
+        AND _from._to_moorage_id IS NOT NULL
+        AND s.name IS NOT NULL
+        AND s.stay_code = sa.stay_code
+        AND s.moorage_id = m.id
+    ORDER BY s.arrived DESC;
+-- Description
+COMMENT ON VIEW
+    api.stay_view
+    IS 'Stay web view';
+
+-- Moorages web view
+-- TODO, this is wrong using distinct (m.name) should be using postgis geog feature
+--DROP VIEW IF EXISTS api.moorages_view_old;
+--CREATE VIEW api.moorages_view_old AS
+--    SELECT
+--        m.name AS Moorage,
+--        sa.description AS "Default Stay",
+--        sum((m.departed-m.arrived)) OVER (PARTITION by m.name) AS "Total Stay",
+--        count(m.departed) OVER (PARTITION by m.name) AS "Arrivals & Departures"
+--    FROM api.moorages m, api.stays_at sa
+--    WHERE departed is not null 
+--        AND m.name is not null
+--        AND m.stay_code = sa.stay_code
+--    GROUP BY m.name,sa.description,m.departed,m.arrived
+--    ORDER BY 4 DESC;
+
+-- the good way?
+DROP VIEW IF EXISTS api.moorages_view;
+CREATE OR REPLACE VIEW api.moorages_view WITH (security_invoker=true,security_barrier=true) AS -- TODO
+    SELECT m.id,
+        m.name AS Moorage,
+        sa.description AS Default_Stay,
+        sa.stay_code AS Default_Stay_Id,
+        EXTRACT(DAY FROM justify_hours ( m.stay_duration )) AS Total_Stay, -- in days
+        m.stay_duration AS Total_Duration,
+        m.reference_count AS Arrivals_Departures
+--        m.geog
+--        m.stay_duration,
+--        justify_hours ( m.stay_duration )
+    FROM api.moorages m, api.stays_at sa
+-- m.stay_duration is only process on a stay
+    WHERE m.stay_duration IS NOT NULL
+        AND m.geog IS NOT NULL
+        AND m.stay_code = sa.stay_code
+   GROUP BY m.id,m.name,sa.description,m.stay_duration,m.reference_count,m.geog,sa.stay_code
+--   ORDER BY 4 DESC;
+--   ORDER BY m.reference_count DESC;
+    ORDER BY m.stay_duration DESC;
+-- Description
+COMMENT ON VIEW
+    api.moorages_view
+    IS 'Moorages listing web view';
+
+DROP VIEW IF EXISTS api.moorage_view;
+CREATE OR REPLACE VIEW api.moorage_view WITH (security_invoker=true,security_barrier=true) AS -- TODO
+    SELECT id,
+        m.name AS Name,
+        sa.description AS Default_Stay,
+        sa.stay_code AS Default_Stay_Id,
+        m.home_flag AS Home,
+        EXTRACT(DAY FROM justify_hours ( m.stay_duration )) AS Total_Stay,
+        m.stay_duration AS Total_Duration,
+        m.reference_count AS Arrivals_Departures,
+        m.notes
+--        m.geog
+    FROM api.moorages m, api.stays_at sa
+-- m.stay_duration is only process on a stay
+    WHERE m.stay_duration IS NOT NULL
+        AND geog IS NOT NULL
+        AND m.stay_code = sa.stay_code;
+-- Description
+COMMENT ON VIEW
+    api.moorage_view
+    IS 'Moorage details web view';
+
+DROP VIEW IF EXISTS api.moorages_stays_view;
+CREATE OR REPLACE VIEW api.moorages_stays_view WITH (security_invoker=true,security_barrier=true) AS
+    SELECT
+        _to.id AS _to_id,
+        _to._to_time,
+        _from.id AS _from_id,
+        _from._from_time,
+        s.stay_code,s.duration,m.id
+	    FROM api.stays_at sa, api.moorages m, api.stays s
+	    LEFT JOIN api.logbook AS _from ON _from._from_time = s.departed
+	    LEFT JOIN api.logbook AS _to ON _to._to_time = s.arrived
+	    WHERE s.departed IS NOT NULL
+	        AND s.name IS NOT NULL
+	        AND s.stay_code = sa.stay_code
+	        AND s.moorage_id = m.id
+        ORDER BY _to._to_time DESC;
+-- Description
+COMMENT ON VIEW
+    api.moorages_stays_view
+    IS 'Moorages stay listing web view';
+
+-- All moorage in 100 meters from the start of a logbook.
+-- ST_DistanceSphere Returns minimum distance in meters between two lon/lat points.
+--SELECT
+--    m.name, ST_MakePoint(m._lng,m._lat),
+--    l._from, ST_MakePoint(l._from_lng,l._from_lat),
+--    ST_DistanceSphere(ST_MakePoint(m._lng,m._lat), ST_MakePoint(l._from_lng,l._from_lat))
+--    FROM  api.moorages m , api.logbook l 
+--    WHERE ST_DistanceSphere(ST_MakePoint(m._lng,m._lat), ST_MakePoint(l._from_lng,l._from_lat)) <= 100;
+
+-- Stats web view
+-- TODO....
+-- first time entry from metrics
+----> select * from api.metrics m ORDER BY m.time desc limit 1
+-- last time entry from metrics
+----> select * from api.metrics m ORDER BY m.time asc limit 1
+-- max speed from logbook
+-- max wind speed from logbook
+----> select max(l.max_speed) as max_speed, max(l.max_wind_speed) as max_wind_speed from api.logbook l;
+-- Total Distance from logbook
+----> select sum(l.distance) as "Total Distance" from api.logbook l;
+-- Total Time Underway from logbook
+----> select sum(l.duration) as "Total Time Underway" from api.logbook l;
+-- Longest Nonstop Sail from logbook, eg longest trip duration and distance
+----> select max(l.duration),max(l.distance) from api.logbook l;
+CREATE OR REPLACE VIEW api.stats_logs_view WITH (security_invoker=true,security_barrier=true) AS -- TODO
+    WITH
+        meta AS ( 
+            SELECT m.name FROM api.metadata m ),
+        last_metric AS ( 
+            SELECT m.time FROM api.metrics m ORDER BY m.time DESC limit 1),
+        first_metric AS (
+            SELECT m.time FROM api.metrics m ORDER BY m.time ASC limit 1),
+        logbook AS (
+            SELECT
+                count(*) AS "number_of_log_entries",
+                max(l.max_speed) AS "max_speed",
+                max(l.max_wind_speed) AS "max_wind_speed",
+                sum(l.distance) AS "total_distance",
+                sum(l.duration) AS "total_time_underway",
+                concat( max(l.distance), ' NM, ', max(l.duration), ' hours') AS "longest_nonstop_sail"
+            FROM api.logbook l)
+    SELECT
+        m.name AS name,
+        fm.time AS first,
+        lm.time AS last,
+        l.* 
+    FROM first_metric fm, last_metric lm, logbook l, meta m;
+COMMENT ON VIEW
+    api.stats_logs_view
+    IS 'Statistics Logs web view';
+
+-- Home Ports / Unique Moorages
+----> select count(*) as "Home Ports" from api.moorages m where home_flag is true;
+-- Unique Moorages
+----> select count(*) as "Home Ports" from api.moorages m;
+-- Time Spent at Home Port(s)
+----> select sum(m.stay_duration) as "Time Spent at Home Port(s)" from api.moorages m where home_flag is true;
+-- OR
+----> select m.stay_duration as "Time Spent at Home Port(s)" from api.moorages m where home_flag is true;
+-- Time Spent Away
+----> select sum(m.stay_duration) as "Time Spent Away" from api.moorages m where home_flag is false;
+-- Time Spent Away order by, group by stay_code (Dock, Anchor, Mooring Buoys, Unclassified)
+----> select sa.description,sum(m.stay_duration) as "Time Spent Away" from api.moorages m, api.stays_at sa where home_flag is false AND m.stay_code = sa.stay_code group by m.stay_code,sa.description order by m.stay_code;
+CREATE OR REPLACE VIEW api.stats_moorages_view WITH (security_invoker=true,security_barrier=true) AS -- TODO
+    WITH
+        home_ports AS (
+            select count(*) as home_ports from api.moorages m where home_flag is true
+        ),
+        unique_moorage AS (
+            select count(*) as unique_moorage from api.moorages m
+        ),
+        time_at_home_ports AS (
+            select sum(m.stay_duration) as time_at_home_ports from api.moorages m where home_flag is true
+        ),
+        time_spent_away AS (
+            select sum(m.stay_duration) as time_spent_away from api.moorages m where home_flag is false
+        )
+    SELECT
+        home_ports.home_ports as "home_ports",
+        unique_moorage.unique_moorage as "unique_moorages",
+        time_at_home_ports.time_at_home_ports "time_spent_at_home_port(s)",
+        time_spent_away.time_spent_away as "time_spent_away"
+    FROM home_ports, unique_moorage, time_at_home_ports, time_spent_away;
+COMMENT ON VIEW
+    api.stats_moorages_view
+    IS 'Statistics Moorages web view';
+
+CREATE OR REPLACE VIEW api.stats_moorages_away_view WITH (security_invoker=true,security_barrier=true) AS -- TODO
+    SELECT sa.description,sum(m.stay_duration) as time_spent_away_by
+    FROM api.moorages m, api.stays_at sa
+    WHERE home_flag IS false
+        AND m.stay_code = sa.stay_code
+    GROUP BY m.stay_code,sa.description
+    ORDER BY m.stay_code;
+COMMENT ON VIEW
+    api.stats_moorages_away_view
+    IS 'Statistics Moorages Time Spent Away web view';
+
+--CREATE VIEW api.stats_view AS -- todo
+--    WITH
+--        logs AS (
+--            SELECT * FROM api.stats_logs_view ),
+--        moorages AS (
+--            SELECT * FROM api.stats_moorages_view)
+--    SELECT
+--        l.*,
+--        m.*
+--        FROM logs l, moorages m;
+--COMMENT ON VIEW
+--    api.stats_moorages_away_view
+--    IS 'Statistics Moorages Time Spent Away web view';
+
+-- View main monitoring for web app
+DROP VIEW IF EXISTS api.monitoring_view;
+CREATE VIEW api.monitoring_view WITH (security_invoker=true,security_barrier=true) AS
+    SELECT 
+        time AS "time",
+        (NOW() AT TIME ZONE 'UTC' - time) > INTERVAL '70 MINUTES' as offline,
+        metrics-> 'environment.water.temperature' AS waterTemperature,
+        metrics-> 'environment.inside.temperature' AS insideTemperature,
+        metrics-> 'environment.outside.temperature' AS outsideTemperature,
+        metrics-> 'environment.wind.speedOverGround' AS windSpeedOverGround,
+        metrics-> 'environment.wind.directionTrue' AS windDirectionTrue,
+        metrics-> 'environment.inside.relativeHumidity' AS insideHumidity,
+        metrics-> 'environment.outside.relativeHumidity' AS outsideHumidity,
+        metrics-> 'environment.outside.pressure' AS outsidePressure,
+        metrics-> 'environment.inside.pressure' AS insidePressure,
+        metrics-> 'electrical.batteries.House.capacity.stateOfCharge' AS batteryCharge,
+        metrics-> 'electrical.batteries.House.voltage' AS batteryVoltage,
+        metrics-> 'environment.depth.belowTransducer' AS depth,
+        jsonb_build_object(
+            'type', 'Feature',
+            'geometry', ST_AsGeoJSON(st_makepoint(longitude,latitude))::jsonb,
+            'properties', jsonb_build_object(
+                'name', current_setting('vessel.name', false),
+                'latitude', m.latitude,
+                'longitude', m.longitude,
+                'time', m.time,
+                'speedoverground', m.speedoverground,
+                'windspeedapparent', m.windspeedapparent
+                )::jsonb ) AS geojson,
+        current_setting('vessel.name', false) AS name
+        --( SELECT api.status_fn() ) AS status
+    FROM api.metrics m
+    ORDER BY time DESC LIMIT 1;
+COMMENT ON VIEW
+    api.monitoring_view
+    IS 'Monitoring static web view';
+
+DROP VIEW IF EXISTS api.monitoring_humidity;
+CREATE VIEW api.monitoring_humidity WITH (security_invoker=true,security_barrier=true) AS
+    SELECT m.time, key, value
+        FROM api.metrics m,
+            jsonb_each_text(m.metrics)
+        WHERE key ILIKE 'environment.%.humidity' OR key ILIKE 'environment.%.relativeHumidity'
+        ORDER BY m.time DESC;
+COMMENT ON VIEW
+    api.monitoring_humidity
+    IS 'Monitoring environment.%.humidity web view';
+
+-- View System RPI monitoring for grafana
+-- View Electric monitoring for grafana
+
+-- View main monitoring for grafana
+-- LAST Monitoring data from json!
+DROP VIEW IF EXISTS api.monitoring_temperatures;
+CREATE VIEW api.monitoring_temperatures WITH (security_invoker=true,security_barrier=true) AS
+    SELECT m.time, key, value
+        FROM api.metrics m,
+            jsonb_each_text(m.metrics)
+        WHERE key ILIKE 'environment.%.temperature'
+        ORDER BY m.time DESC;
+COMMENT ON VIEW
+    api.monitoring_temperatures
+    IS 'Monitoring environment.%.temperature web view';
+
+-- json key regexp
+-- https://stackoverflow.com/questions/38204467/selecting-for-a-jsonb-array-contains-regex-match
+-- Last voltage data from json!
+DROP VIEW IF EXISTS api.monitoring_voltage;
+CREATE VIEW api.monitoring_voltage WITH (security_invoker=true,security_barrier=true) AS
+    SELECT m.time, key, value
+        FROM api.metrics m,
+            jsonb_each_text(m.metrics)
+        WHERE key ILIKE 'electrical.%.voltage'
+        ORDER BY m.time DESC;
+COMMENT ON VIEW
+    api.monitoring_voltage
+    IS 'Monitoring electrical.%.voltage web view';
+
+-- Last whatever data from json!
+DROP VIEW IF EXISTS api.monitoring_view2;
+CREATE VIEW api.monitoring_view2 WITH (security_invoker=true,security_barrier=true) AS
+    SELECT
+         *
+        FROM
+            jsonb_each(
+                ( SELECT metrics FROM api.metrics m ORDER BY time DESC LIMIT 1)
+            );
+    --      WHERE key ilike 'tanks.%.capacity%'
+    --          or key ilike 'electrical.solar.%.panelPower'
+    --          or key ilike 'electrical.batteries%stateOfCharge'
+    --          or key ilike 'tanks\.%currentLevel'
+COMMENT ON VIEW
+    api.monitoring_view2
+    IS 'Monitoring Last whatever data from json web view';
+
+-- Timeseries whatever data from json!
+DROP VIEW IF EXISTS api.monitoring_view3;
+CREATE VIEW api.monitoring_view3 WITH (security_invoker=true,security_barrier=true) AS
+    SELECT m.time, key, value
+        FROM api.metrics m,
+            jsonb_each_text(m.metrics)
+         ORDER BY m.time DESC;
+    --    WHERE key ILIKE 'electrical.batteries%voltage';
+    --      WHERE key ilike 'tanks.%.capacity%'
+    --          or key ilike 'electrical.solar.%.panelPower'
+    --          or key ilike 'electrical.batteries%stateOfCharge';
+    -- key ILIKE 'propulsion.%.runTime'
+    -- key ILIKE 'navigation.log'
+COMMENT ON VIEW
+    api.monitoring_view3
+    IS 'Monitoring Timeseries whatever data from json web view';
+
+-- Infotiles web app
+DROP VIEW IF EXISTS api.total_info_view;
+CREATE VIEW api.total_info_view WITH (security_invoker=true,security_barrier=true) AS
+-- Infotiles web app, not used calculated client side
+    WITH
+        l as (SELECT count(*) as logs FROM api.logbook),
+        s as (SELECT count(*) as stays FROM api.stays),
+        m as (SELECT count(*) as moorages FROM api.moorages)
+        SELECT * FROM l,s,m;
+COMMENT ON VIEW
+    api.total_info_view
+    IS 'total_info_view web view';
+
+DROP VIEW IF EXISTS api.explore_view;
+CREATE VIEW api.explore_view WITH (security_invoker=true,security_barrier=true) AS
+-- Expose last metrics
+    WITH raw_metrics AS (
+        SELECT m.time, m.metrics
+            FROM api.metrics m
+            ORDER BY m.time desc limit 1
+        )
+    SELECT raw_metrics.time, key, value
+        FROM raw_metrics,
+            jsonb_each_text(raw_metrics.metrics)
+        ORDER BY key ASC;
+COMMENT ON VIEW
+    api.explore_view
+    IS 'explore_view web view';

initdb/02_2_signalk_cron.sql

@@ -8,19 +8,49 @@ select current_database();
 -- connect to the DB
 \c signalk
 
+-- Check for new logbook pending validation
+CREATE FUNCTION cron_process_pre_logbook_fn() RETURNS void AS $$
+DECLARE
+    process_rec record;
+BEGIN
+    -- Check for new logbook pending update
+    RAISE NOTICE 'cron_process_pre_logbook_fn init loop';
+    FOR process_rec in
+        SELECT * FROM process_queue
+            WHERE channel = 'pre_logbook' AND processed IS NULL
+            ORDER BY stored ASC LIMIT 100
+    LOOP
+        RAISE NOTICE 'cron_process_pre_logbook_fn processing queue [%] for logbook id [%]', process_rec.id, process_rec.payload;
+        -- update logbook
+        PERFORM process_pre_logbook_fn(process_rec.payload::INTEGER);
+        -- update process_queue table , processed
+        UPDATE process_queue
+            SET
+                processed = NOW()
+            WHERE id = process_rec.id;
+        RAISE NOTICE 'cron_process_pre_logbook_fn processed queue [%] for logbook id [%]', process_rec.id, process_rec.payload;
+    END LOOP;
+END;
+$$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_pre_logbook_fn
+    IS 'init by pg_cron to check for new logbook pending update, if so perform process_logbook_valid_fn';
+
+
 -- Check for new logbook pending update
 CREATE FUNCTION cron_process_new_logbook_fn() RETURNS void AS $$
 declare
     process_rec record;
 begin
     -- Check for new logbook pending update
-    RAISE NOTICE 'cron_process_new_logbook_fn';
+    RAISE NOTICE 'cron_process_new_logbook_fn init loop';
     FOR process_rec in 
         SELECT * FROM process_queue 
             WHERE channel = 'new_logbook' AND processed IS NULL
             ORDER BY stored ASC LIMIT 100
     LOOP
-        RAISE NOTICE '-> cron_process_new_logbook_fn [%]', process_rec.payload;
+        RAISE NOTICE 'cron_process_new_logbook_fn processing queue [%] for logbook id [%]', process_rec.id, process_rec.payload;
         -- update logbook
         PERFORM process_logbook_queue_fn(process_rec.payload::INTEGER);
         -- update process_queue table , processed
@@ -28,7 +58,7 @@ begin
             SET 
                 processed = NOW()
             WHERE id = process_rec.id;
-        RAISE NOTICE '-> cron_process_new_logbook_fn updated process_queue table [%]', process_rec.id;
+        RAISE NOTICE 'cron_process_new_logbook_fn processed queue [%] for logbook id [%]', process_rec.id, process_rec.payload;
     END LOOP;
 END;
 $$ language plpgsql;
@@ -43,13 +73,13 @@ declare
     process_rec record;
 begin
     -- Check for new stay pending update
-    RAISE NOTICE 'cron_process_new_stay_fn';
+    RAISE NOTICE 'cron_process_new_stay_fn init loop';
     FOR process_rec in 
         SELECT * FROM process_queue 
             WHERE channel = 'new_stay' AND processed IS NULL
             ORDER BY stored ASC LIMIT 100
     LOOP
-        RAISE NOTICE '-> cron_process_new_stay_fn [%]', process_rec.payload;
+        RAISE NOTICE 'cron_process_new_stay_fn processing queue [%] for stay id [%]', process_rec.id, process_rec.payload;
         -- update stay
         PERFORM process_stay_queue_fn(process_rec.payload::INTEGER);
         -- update process_queue table , processed
@@ -57,7 +87,7 @@ begin
             SET 
                 processed = NOW()
             WHERE id = process_rec.id;
-        RAISE NOTICE '-> cron_process_new_stay_fn updated process_queue table [%]', process_rec.id;
+        RAISE NOTICE 'cron_process_new_stay_fn processed queue [%] for stay id [%]', process_rec.id, process_rec.payload;
     END LOOP;
 END;
 $$ language plpgsql;
@@ -73,13 +103,13 @@ declare
     process_rec record;
 begin
     -- Check for new moorage pending update
-    RAISE NOTICE 'cron_process_new_moorage_fn';
+    RAISE NOTICE 'cron_process_new_moorage_fn init loop';
     FOR process_rec in 
         SELECT * FROM process_queue 
             WHERE channel = 'new_moorage' AND processed IS NULL
             ORDER BY stored ASC LIMIT 100
     LOOP
-        RAISE NOTICE '-> cron_process_new_moorage_fn [%]', process_rec.payload;
+        RAISE NOTICE 'cron_process_new_moorage_fn processing queue [%] for moorage id [%]', process_rec.id, process_rec.payload;
         -- update moorage
         PERFORM process_moorage_queue_fn(process_rec.payload::INTEGER);
         -- update process_queue table , processed
@@ -87,14 +117,14 @@ begin
             SET 
                 processed = NOW()
             WHERE id = process_rec.id;
-        RAISE NOTICE '-> cron_process_new_moorage_fn updated process_queue table [%]', process_rec.id;
+        RAISE NOTICE 'cron_process_new_moorage_fn processed queue [%] for moorage id [%]', process_rec.id, process_rec.payload;
     END LOOP;
 END;
 $$ language plpgsql;
 -- Description
 COMMENT ON FUNCTION
     public.cron_process_new_moorage_fn
-    IS 'init by pg_cron to check for new moorage pending update, if so perform process_moorage_queue_fn';
+    IS 'Deprecated, init by pg_cron to check for new moorage pending update, if so perform process_moorage_queue_fn';
 
 -- CRON Monitor offline pending notification
 create function cron_process_monitor_offline_fn() RETURNS void AS $$
@@ -127,12 +157,12 @@ begin
         IF metadata_rec.vessel_id IS NULL OR metadata_rec.vessel_id = '' THEN
             RAISE WARNING '-> cron_process_monitor_offline_fn invalid metadata record vessel_id %', vessel_id;
             RAISE EXCEPTION 'Invalid metadata'
-                USING HINT = 'Unknow vessel_id';
+                USING HINT = 'Unknown vessel_id';
             RETURN;
         END IF;
         PERFORM set_config('vessel.id', metadata_rec.vessel_id, false);
         RAISE DEBUG '-> DEBUG cron_process_monitor_offline_fn vessel.id %', current_setting('vessel.id', false);
-        RAISE NOTICE '-> cron_process_monitor_offline_fn updated api.metadata table to inactive for [%] [%]', metadata_rec.id, metadata_rec.vessel_id;
+        RAISE NOTICE 'cron_process_monitor_offline_fn updated api.metadata table to inactive for [%] [%]', metadata_rec.id, metadata_rec.vessel_id;
 
         -- Gather email and pushover app settings
         --app_settings = get_app_settings_fn();
@@ -182,7 +212,7 @@ begin
         IF metadata_rec.vessel_id IS NULL OR metadata_rec.vessel_id = '' THEN
             RAISE WARNING '-> cron_process_monitor_online_fn invalid metadata record vessel_id %', vessel_id;
             RAISE EXCEPTION 'Invalid metadata'
-                USING HINT = 'Unknow vessel_id';
+                USING HINT = 'Unknown vessel_id';
             RETURN;
         END IF;
         PERFORM set_config('vessel.id', metadata_rec.vessel_id, false);
@@ -329,13 +359,151 @@ COMMENT ON FUNCTION
     public.cron_process_new_notification_fn
     IS 'init by pg_cron to check for new event pending notifications, if so perform process_notification_queue_fn';
 
+-- CRON for new vessel metadata pending grafana provisioning
+CREATE FUNCTION cron_process_grafana_fn() RETURNS void AS $$
+DECLARE
+    process_rec record;
+    data_rec record;
+    app_settings jsonb;
+    user_settings jsonb;
+BEGIN
+    -- We run grafana provisioning only after the first received vessel metadata
+    -- Check for new vessel metadata pending grafana provisioning
+    RAISE NOTICE 'cron_process_grafana_fn';
+    FOR process_rec in
+        SELECT * from process_queue
+            where channel = 'grafana' and processed is null
+            order by stored asc
+    LOOP
+        RAISE NOTICE '-> cron_process_grafana_fn [%]', process_rec.payload;
+        -- Gather url from app settings
+        app_settings := get_app_settings_fn();
+        -- Get vessel details base on metadata id
+        SELECT * INTO data_rec
+            FROM api.metadata m, auth.vessels v
+            WHERE m.id = process_rec.payload::INTEGER
+                AND m.vessel_id = v.vessel_id;
+        -- as we got data from the vessel we can do the grafana provisioning.
+        PERFORM grafana_py_fn(data_rec.name, data_rec.vessel_id, data_rec.owner_email, app_settings);
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(data_rec.vessel_id::TEXT);
+        --RAISE DEBUG '-> DEBUG cron_process_grafana_fn get_user_settings_from_vesselid_fn [%]', user_settings;
+        -- add user in keycloak
+        PERFORM keycloak_auth_py_fn(data_rec.vessel_id, user_settings, app_settings);
+        -- Send notification
+        PERFORM send_notification_fn('grafana'::TEXT, user_settings::JSONB);
+        -- update process_queue entry as processed
+        UPDATE process_queue
+            SET
+                processed = NOW()
+            WHERE id = process_rec.id;
+        RAISE NOTICE '-> cron_process_grafana_fn updated process_queue table [%]', process_rec.id;
+    END LOOP;
+END;
+$$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_grafana_fn
+    IS 'init by pg_cron to check for new vessel pending grafana provisioning, if so perform grafana_py_fn';
+
+CREATE OR REPLACE FUNCTION public.cron_process_windy_fn() RETURNS void AS $$
+DECLARE
+    windy_rec record;
+    default_last_metric TIMESTAMPTZ := NOW() - interval '1 day';
+    last_metric TIMESTAMPTZ;
+    metric_rec record;
+    windy_metric jsonb;
+    app_settings jsonb;
+    user_settings jsonb;
+    windy_pws jsonb;
+BEGIN
+    -- Check for new observations pending update
+    RAISE NOTICE 'cron_windy_fn';
+    -- Gather url from app settings
+    app_settings := get_app_settings_fn();
+    -- Find users with Windy active and with an active vessel
+    -- Map account id to Windy Station ID
+    FOR windy_rec in
+        SELECT
+            a.id,a.email,v.vessel_id,v.name,
+            COALESCE((a.preferences->'windy_last_metric')::TEXT, default_last_metric::TEXT) as last_metric
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels AS v ON v.owner_email = a.email
+            LEFT JOIN api.metadata AS m ON m.vessel_id = v.vessel_id
+            WHERE (a.preferences->'public_windy')::boolean = True
+                AND m.active = True
+    LOOP
+        RAISE NOTICE '-> cron_windy_fn for [%]', windy_rec;
+        PERFORM set_config('vessel.id', windy_rec.vessel_id, false);
+        --RAISE WARNING 'public.cron_process_windy_rec_fn() scheduler vessel.id %, user.id', current_setting('vessel.id', false), current_setting('user.id', false);
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(windy_rec.vessel_id::TEXT);
+        RAISE NOTICE '-> cron_windy_fn checking user_settings [%]', user_settings;
+        -- Get all metrics from the last windy_last_metric avg by 5 minutes
+        -- TODO json_agg to send all data in once, but issue with py jsonb transformation decimal. 
+        FOR metric_rec in
+            SELECT time_bucket('5 minutes', m.time) AS time_bucket,
+                    avg((m.metrics->'environment.outside.temperature')::numeric) AS temperature,
+                    avg((m.metrics->'environment.outside.pressure')::numeric) AS pressure,
+                    avg((m.metrics->'environment.outside.relativeHumidity')::numeric) AS rh,
+                    avg((m.metrics->'environment.wind.directionTrue')::numeric) AS winddir,
+                    avg((m.metrics->'environment.wind.speedTrue')::numeric) AS wind,
+                    max((m.metrics->'environment.wind.speedTrue')::numeric) AS gust,
+                    last(latitude, time) AS lat,
+                    last(longitude, time) AS lng
+                FROM api.metrics m
+                WHERE vessel_id = windy_rec.vessel_id
+                    AND m.time >= windy_rec.last_metric::TIMESTAMPTZ
+                GROUP BY time_bucket
+                ORDER BY time_bucket ASC LIMIT 100
+        LOOP
+            RAISE NOTICE '-> cron_windy_fn checking metrics [%]', metric_rec;
+            -- https://community.windy.com/topic/8168/report-your-weather-station-data-to-windy
+            -- temp from kelvin to celcuis
+            -- winddir from radiant to degres
+            -- rh from ratio to percentage
+            SELECT jsonb_build_object(
+                'dateutc', metric_rec.time_bucket,
+                'station', windy_rec.id,
+                'name', windy_rec.name,
+                'lat', metric_rec.lat,
+                'lon', metric_rec.lng,
+                'wind', metric_rec.wind,
+                'gust', metric_rec.gust,
+                'pressure', metric_rec.pressure,
+                'winddir', radiantToDegrees(metric_rec.winddir::numeric),
+                'temp', kelvinToCel(metric_rec.temperature::numeric),
+                'rh', valToPercent(metric_rec.rh::numeric)
+                ) INTO windy_metric;
+            RAISE NOTICE '-> cron_windy_fn checking windy_metrics [%]', windy_metric;
+            SELECT windy_pws_py_fn(windy_metric, user_settings, app_settings) into windy_pws;
+            RAISE NOTICE '-> cron_windy_fn Windy PWS [%]', ((windy_pws->'header')::JSONB ? 'id');
+            IF NOT((user_settings->'settings')::JSONB ? 'windy') and ((windy_pws->'header')::JSONB ? 'id') then
+                RAISE NOTICE '-> cron_windy_fn new Windy PWS [%]', (windy_pws->'header')::JSONB->>'id';
+                -- Send metrics to Windy
+                PERFORM api.update_user_preferences_fn('{windy}'::TEXT, ((windy_pws->'header')::JSONB->>'id')::TEXT);
+                -- Send notification
+                PERFORM send_notification_fn('windy'::TEXT, user_settings::JSONB);
+            END IF;
+            -- Record last metrics time
+            SELECT metric_rec.time_bucket INTO last_metric;
+        END LOOP;
+        PERFORM api.update_user_preferences_fn('{windy_last_metric}'::TEXT, last_metric::TEXT);
+    END LOOP;
+END;
+$$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_windy_fn
+    IS 'init by pg_cron to create (or update) station and uploading observations to Windy Personal Weather Station observations';
+
 -- CRON for Vacuum database
-CREATE FUNCTION cron_vaccum_fn() RETURNS void AS $$
+CREATE FUNCTION cron_vacuum_fn() RETURNS void AS $$
 -- ERROR:  VACUUM cannot be executed from a function
 declare
 begin
     -- Vacuum
-    RAISE NOTICE 'cron_vaccum_fn';
+    RAISE NOTICE 'cron_vacuum_fn';
     VACUUM (FULL, VERBOSE, ANALYZE, INDEX_CLEANUP) api.logbook;
     VACUUM (FULL, VERBOSE, ANALYZE, INDEX_CLEANUP) api.stays;
     VACUUM (FULL, VERBOSE, ANALYZE, INDEX_CLEANUP) api.moorages;
@@ -345,44 +513,480 @@ END;
 $$ language plpgsql;
 -- Description
 COMMENT ON FUNCTION 
-    public.cron_vaccum_fn
-    IS 'init by pg_cron to full vaccum tables on schema api';
-
--- CRON for Vacuum database
-CREATE FUNCTION job_run_details_cleanup_fn() RETURNS void AS $$
-DECLARE
-BEGIN
-    -- Remove job run log older than 3 months
-    RAISE NOTICE 'job_run_details_cleanup_fn';
-    DELETE FROM postgres.cron.job_run_details
-        WHERE start_time <= NOW() AT TIME ZONE 'UTC' - INTERVAL '91 DAYS';
-END;
-$$ language plpgsql;
--- Description
-COMMENT ON FUNCTION
-    public.cron_vaccum_fn
-    IS 'init by pg_cron to cleanup job_run_details table on schema public postgras db';
+    public.cron_vacuum_fn
+    IS 'init by pg_cron to full vacuum tables on schema api';
 
 -- CRON for alerts notification
-CREATE FUNCTION cron_process_alerts_fn() RETURNS void AS $$
+CREATE OR REPLACE FUNCTION public.cron_alerts_fn() RETURNS void AS $$
 DECLARE
     alert_rec record;
+    default_last_metric TIMESTAMPTZ := NOW() - interval '1 day';
+    last_metric TIMESTAMPTZ;
+    metric_rec record;
+    app_settings JSONB;
+    user_settings JSONB;
+    alerting JSONB;
+    _alarms JSONB;
+    alarms TEXT;
+    alert_default JSONB := '{
+        "low_pressure_threshold": 990,
+        "high_wind_speed_threshold": 30,
+        "low_water_depth_threshold": 1,
+        "min_notification_interval": 6,
+        "high_pressure_drop_threshold": 12,
+        "low_battery_charge_threshold": 90,
+        "low_battery_voltage_threshold": 12.5,
+        "low_water_temperature_threshold": 10,
+        "low_indoor_temperature_threshold": 7,
+        "low_outdoor_temperature_threshold": 3
+    }';
 BEGIN
     -- Check for new event notification pending update
-    RAISE NOTICE 'cron_process_alerts_fn';
+    RAISE NOTICE 'cron_alerts_fn';
     FOR alert_rec in
         SELECT
-            a.user_id,a.email,v.vessel_id
-            FROM auth.accounts a, auth.vessels v, api.metadata m
-            WHERE m.vessel_id = v.vessel_id
-                AND a.email = v.owner_email
-                AND (preferences->'alerting'->'enabled')::boolean = false
+            a.user_id,a.email,v.vessel_id,
+            COALESCE((a.preferences->'alert_last_metric')::TEXT, default_last_metric::TEXT) as last_metric,
+            (alert_default || (a.preferences->'alerting')::JSONB) as alerting,
+            (a.preferences->'alarms')::JSONB as alarms
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels AS v ON v.owner_email = a.email
+            LEFT JOIN api.metadata AS m ON m.vessel_id = v.vessel_id
+            WHERE (a.preferences->'alerting'->'enabled')::boolean = True
+                AND m.active = True
         LOOP
-        RAISE NOTICE '-> cron_process_alert_rec_fn for [%]', alert_rec;
+        RAISE NOTICE '-> cron_alerts_fn for [%]', alert_rec;
+        PERFORM set_config('vessel.id', alert_rec.vessel_id, false);
+        PERFORM set_config('user.email', alert_rec.email, false);
+        --RAISE WARNING 'public.cron_process_alert_rec_fn() scheduler vessel.id %, user.id', current_setting('vessel.id', false), current_setting('user.id', false);
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(alert_rec.vessel_id::TEXT);
+        RAISE NOTICE '-> cron_alerts_fn checking user_settings [%]', user_settings;
+        -- Get all metrics from the last last_metric avg by 5 minutes
+        FOR metric_rec in
+            SELECT time_bucket('5 minutes', m.time) AS time_bucket,
+                    avg((m.metrics->'environment.inside.temperature')::numeric) AS intemp,
+                    avg((m.metrics->'environment.outside.temperature')::numeric) AS outtemp,
+                    avg((m.metrics->'environment.water.temperature')::numeric) AS wattemp,
+                    avg((m.metrics->'environment.depth.belowTransducer')::numeric) AS watdepth,
+                    avg((m.metrics->'environment.outside.pressure')::numeric) AS pressure,
+                    avg((m.metrics->'environment.wind.speedTrue')::numeric) AS wind,
+                    avg((m.metrics->'electrical.batteries.House.voltage')::numeric) AS voltage,
+                    avg((m.metrics->'electrical.batteries.House.capacity.stateOfCharge')::numeric) AS charge
+                FROM api.metrics m
+                WHERE vessel_id = alert_rec.vessel_id
+                    AND m.time >= alert_rec.last_metric::TIMESTAMPTZ
+                GROUP BY time_bucket
+                ORDER BY time_bucket ASC LIMIT 100
+        LOOP
+            RAISE NOTICE '-> cron_alerts_fn checking metrics [%]', metric_rec;
+            RAISE NOTICE '-> cron_alerts_fn checking alerting [%]', alert_rec.alerting;
+            --RAISE NOTICE '-> cron_alerts_fn checking debug [%] [%]', kelvinToCel(metric_rec.intemp), (alert_rec.alerting->'low_indoor_temperature_threshold');
+            IF kelvinToCel(metric_rec.intemp) < (alert_rec.alerting->'low_indoor_temperature_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_indoor_temperature_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_indoor_temperature_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_indoor_temperature_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_indoor_temperature_threshold": {"value": '|| kelvinToCel(metric_rec.intemp) ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_outdoor_temperature_threshold value:'|| kelvinToCel(metric_rec.intemp) ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_indoor_temperature_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_indoor_temperature_threshold';
+            END IF;
+            IF kelvinToCel(metric_rec.outtemp) < (alert_rec.alerting->'low_outdoor_temperature_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_outdoor_temperature_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_outdoor_temperature_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_outdoor_temperature_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_outdoor_temperature_threshold": {"value": '|| kelvinToCel(metric_rec.outtemp) ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_outdoor_temperature_threshold value:'|| kelvinToCel(metric_rec.outtemp) ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_outdoor_temperature_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_outdoor_temperature_threshold';
+            END IF;
+            IF kelvinToCel(metric_rec.wattemp) < (alert_rec.alerting->'low_water_temperature_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_water_temperature_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_water_temperature_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_water_temperature_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_water_temperature_threshold": {"value": '|| kelvinToCel(metric_rec.wattemp) ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_water_temperature_threshold value:'|| kelvinToCel(metric_rec.wattemp) ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_water_temperature_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_water_temperature_threshold';
+            END IF;
+            IF metric_rec.watdepth < (alert_rec.alerting->'low_water_depth_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_water_depth_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_water_depth_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_water_depth_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_water_depth_threshold": {"value": '|| metric_rec.watdepth ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_water_depth_threshold value:'|| metric_rec.watdepth ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_water_depth_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_water_depth_threshold';
+            END IF;
+            if metric_rec.pressure < (alert_rec.alerting->'high_pressure_drop_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'high_pressure_drop_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'high_pressure_drop_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'high_pressure_drop_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"high_pressure_drop_threshold": {"value": '|| metric_rec.pressure ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "high_pressure_drop_threshold value:'|| metric_rec.pressure ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug high_pressure_drop_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug high_pressure_drop_threshold';
+            END IF;
+            IF metric_rec.wind > (alert_rec.alerting->'high_wind_speed_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'high_wind_speed_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'high_wind_speed_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'high_wind_speed_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"high_wind_speed_threshold": {"value": '|| metric_rec.wind ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "high_wind_speed_threshold value:'|| metric_rec.wind ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug high_wind_speed_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug high_wind_speed_threshold';
+            END IF;
+            if metric_rec.voltage < (alert_rec.alerting->'low_battery_voltage_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_battery_voltage_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = 'lacroix.francois@gmail.com';
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_battery_voltage_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_battery_voltage_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_battery_voltage_threshold": {"value": '|| metric_rec.voltage ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_battery_voltage_threshold value:'|| metric_rec.voltage ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_battery_voltage_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_battery_voltage_threshold';
+            END IF;
+            if (metric_rec.charge*100) < (alert_rec.alerting->'low_battery_charge_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_battery_charge_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_battery_charge_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_battery_charge_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_battery_charge_threshold": {"value": '|| (metric_rec.charge*100) ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_battery_charge_threshold value:'|| (metric_rec.charge*100) ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_battery_charge_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_battery_charge_threshold';
+            END IF;
+            -- Record last metrics time
+            SELECT metric_rec.time_bucket INTO last_metric;
+        END LOOP;
+        PERFORM api.update_user_preferences_fn('{alert_last_metric}'::TEXT, last_metric::TEXT);
     END LOOP;
 END;
 $$ language plpgsql;
 -- Description
 COMMENT ON FUNCTION
-    public.cron_process_alerts_fn
-    IS 'init by pg_cron to check for alerts, if so perform process_alerts_queue_fn';
+    public.cron_alerts_fn
+    IS 'init by pg_cron to check for alerts';
+
+-- CRON for no vessel notification
+CREATE FUNCTION cron_process_no_vessel_fn() RETURNS void AS $no_vessel$
+DECLARE
+    no_vessel record;
+    user_settings jsonb;
+BEGIN
+    -- Check for user with no vessel register
+    RAISE NOTICE 'cron_process_no_vessel_fn';
+    FOR no_vessel in
+        SELECT a.user_id,a.email,a.first
+            FROM auth.accounts a
+            WHERE NOT EXISTS (
+                SELECT *
+                FROM auth.vessels v
+                WHERE v.owner_email = a.email)
+    LOOP
+        RAISE NOTICE '-> cron_process_no_vessel_rec_fn for [%]', no_vessel;
+        SELECT json_build_object('email', no_vessel.email, 'recipient', no_vessel.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_no_vessel_rec_fn [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('no_vessel'::TEXT, user_settings::JSONB);
+    END LOOP;
+END;
+$no_vessel$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_no_vessel_fn
+    IS 'init by pg_cron, check for user with no vessel register then send notification';
+
+-- CRON for no metadata notification
+CREATE FUNCTION cron_process_no_metadata_fn() RETURNS void AS $no_metadata$
+DECLARE
+    no_metadata_rec record;
+    user_settings jsonb;
+BEGIN
+    -- Check for vessel register but with no metadata
+    RAISE NOTICE 'cron_process_no_metadata_fn';
+    FOR no_metadata_rec in
+        SELECT
+            a.user_id,a.email,a.first
+            FROM auth.accounts a, auth.vessels v
+            WHERE NOT EXISTS (
+                SELECT *
+                FROM  api.metadata m
+                WHERE v.vessel_id = m.vessel_id) AND v.owner_email = a.email
+    LOOP
+        RAISE NOTICE '-> cron_process_no_metadata_rec_fn for [%]', no_metadata_rec;
+        SELECT json_build_object('email', no_metadata_rec.email, 'recipient', no_metadata_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_no_metadata_rec_fn [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('no_metadata'::TEXT, user_settings::JSONB);
+    END LOOP;
+END;
+$no_metadata$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_no_metadata_fn
+    IS 'init by pg_cron, check for vessel with no metadata then send notification';
+
+-- CRON for no activity notification
+CREATE FUNCTION cron_process_no_activity_fn() RETURNS void AS $no_activity$
+DECLARE
+    no_activity_rec record;
+    user_settings jsonb;
+BEGIN
+    -- Check for vessel with no activity for more than 230 days
+    RAISE NOTICE 'cron_process_no_activity_fn';
+    FOR no_activity_rec in
+        SELECT
+            v.owner_email,m.name,m.vessel_id,m.time,a.first
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels v ON v.owner_email = a.email
+            LEFT JOIN api.metadata m ON v.vessel_id = m.vessel_id
+            WHERE m.time < NOW() AT TIME ZONE 'UTC' - INTERVAL '230 DAYS'
+    LOOP
+        RAISE NOTICE '-> cron_process_no_activity_rec_fn for [%]', no_activity_rec;
+        SELECT json_build_object('email', no_activity_rec.owner_email, 'recipient', no_activity_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_no_activity_rec_fn [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('no_activity'::TEXT, user_settings::JSONB);
+    END LOOP;
+END;
+$no_activity$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_no_activity_fn
+    IS 'init by pg_cron, check for vessel with no activity for more than 230 days then send notification';
+
+-- CRON for deactivated/deletion
+CREATE FUNCTION cron_process_deactivated_fn() RETURNS void AS $deactivated$
+DECLARE
+    no_activity_rec record;
+    user_settings jsonb;
+BEGIN
+    RAISE NOTICE 'cron_process_deactivated_fn';
+
+    -- List accounts with vessel inactivity for more than 1 YEAR
+    FOR no_activity_rec in
+        SELECT
+            v.owner_email,m.name,m.vessel_id,m.time,a.first
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels v ON v.owner_email = a.email
+            LEFT JOIN api.metadata m ON v.vessel_id = m.vessel_id
+            WHERE m.time < NOW() AT TIME ZONE 'UTC' - INTERVAL '1 YEAR'
+    LOOP
+        RAISE NOTICE '-> cron_process_deactivated_rec_fn for inactivity [%]', no_activity_rec;
+        SELECT json_build_object('email', no_activity_rec.owner_email, 'recipient', no_activity_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_deactivated_rec_fn inactivity [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('deactivated'::TEXT, user_settings::JSONB);
+        --PERFORM public.delete_account_fn(no_activity_rec.owner_email::TEXT, no_activity_rec.vessel_id::TEXT);
+    END LOOP;
+
+    -- List accounts with no vessel metadata for more than 1 YEAR
+    FOR no_activity_rec in
+        SELECT
+            a.user_id,a.email,a.first,a.created_at
+            FROM auth.accounts a, auth.vessels v
+            WHERE NOT EXISTS (
+                SELECT *
+                FROM  api.metadata m
+                WHERE v.vessel_id = m.vessel_id) AND v.owner_email = a.email
+            AND v.created_at < NOW() AT TIME ZONE 'UTC' - INTERVAL '1 YEAR'
+    LOOP
+        RAISE NOTICE '-> cron_process_deactivated_rec_fn for no metadata [%]', no_activity_rec;
+        SELECT json_build_object('email', no_activity_rec.owner_email, 'recipient', no_activity_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_deactivated_rec_fn no metadata [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('deactivated'::TEXT, user_settings::JSONB);
+        --PERFORM public.delete_account_fn(no_activity_rec.owner_email::TEXT, no_activity_rec.vessel_id::TEXT);
+    END LOOP;
+
+    -- List accounts with no vessel created for more than 1 YEAR
+    FOR no_activity_rec in
+        SELECT a.user_id,a.email,a.first,a.created_at
+            FROM auth.accounts a
+            WHERE NOT EXISTS (
+                SELECT *
+                FROM auth.vessels v
+                WHERE v.owner_email = a.email)
+            AND a.created_at < NOW() AT TIME ZONE 'UTC' - INTERVAL '1 YEAR'
+    LOOP
+        RAISE NOTICE '-> cron_process_deactivated_rec_fn for no vessel [%]', no_activity_rec;
+        SELECT json_build_object('email', no_activity_rec.owner_email, 'recipient', no_activity_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_deactivated_rec_fn no vessel [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('deactivated'::TEXT, user_settings::JSONB);
+        --PERFORM public.delete_account_fn(no_activity_rec.owner_email::TEXT, no_activity_rec.vessel_id::TEXT);
+    END LOOP;
+END;
+$deactivated$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_deactivated_fn
+    IS 'init by pg_cron, check for vessel with no activity for more than 1 year then send notification and delete data';
+
+-- Need to be in the postgres database.
+\c postgres
+-- CRON for clean up job details logs
+CREATE FUNCTION public.job_run_details_cleanup_fn() RETURNS void AS $$
+DECLARE
+BEGIN
+    -- Remove job run log older than 3 months
+    RAISE NOTICE 'job_run_details_cleanup_fn';
+    DELETE FROM cron.job_run_details
+        WHERE start_time <= NOW() AT TIME ZONE 'UTC' - INTERVAL '91 DAYS';
+END;
+$$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.job_run_details_cleanup_fn
+    IS 'init by pg_cron to cleanup job_run_details table on schema public postgres db';

initdb/02_3_1_signalk_public_tables.sql

@@ -52,7 +52,7 @@ COMMENT ON TABLE
 -- with escape value, eg: E'A\nB\r\nC'
 -- https://stackoverflow.com/questions/26638615/insert-line-break-in-postgresql-when-updating-text-field
 -- TODO Update notification subject for log entry to 'logbook #NB ...'
-INSERT INTO email_templates VALUES
+INSERT INTO public.email_templates VALUES
 ('logbook',
     'New Logbook Entry',
     E'Hello __RECIPIENT__,\n\nWe just wanted to let you know that you have a new entry on openplotter.cloud: "__LOGBOOK_NAME__"\r\n\r\nSee more details at __APP_URL__/log/__LOGBOOK_LINK__\n\nHappy sailing!\nThe PostgSail Team',
@@ -64,19 +64,19 @@ INSERT INTO email_templates VALUES
     'Welcome',
     E'Hi!\nYou successfully created an account\nKeep in mind to register your vessel.\n'),
 ('new_vessel',
-    'New vessel',
+    'New boat',
     E'Hi!\nHow are you?\n__BOAT__ is now linked to your account.\n',
-    'New vessel',
+    'New boat',
     E'Hi!\nHow are you?\n__BOAT__ is now linked to your account.\n'),
 ('monitor_offline',
-    'Vessel Offline',
+    'Boat went Offline',
     E'__BOAT__ has been offline for more than an hour\r\nFind more details at __APP_URL__/boats\n',
-    'Vessel Offline',
+    'Boat went Offline',
     E'__BOAT__ has been offline for more than an hour\r\nFind more details at __APP_URL__/boats\n'),
 ('monitor_online',
-    'Vessel Online',
+    'Boat went Online',
     E'__BOAT__ just came online\nFind more details at __APP_URL__/boats\n',
-    'Vessel Online',
+    'Boat went Online',
     E'__BOAT__ just came online\nFind more details at __APP_URL__/boats\n'),
 ('new_badge',
     'New Badge!',
@@ -100,19 +100,54 @@ INSERT INTO email_templates VALUES
     E'Hi!\nYou successfully validate your account.\n'),
 ('email_reset',
     'Password reset',
-    E'Hello,\nYou requested a password reset. To reset your password __APP_URL__/reset?__RESET_QS__.\nThe PostgSail Team',
+    E'Hello,\nYou requested a password reset. To reset your password __APP_URL__/reset-password?__RESET_QS__.\nThe PostgSail Team',
     'Password reset',
     E'You requested a password recovery. Check your email!\n'),
 ('telegram_otp',
     'Telegram bot',
-    E'Hello,\nTo connect your account to a @postgsail_bot. Please type this verification code __OTP_CODE__ back to the bot.\nThe code is valid 15 minutes.\nThe PostgSail Team',
+    E'Hello,\nTo connect your account to a @postgsail_bot. Please type this verification code __OTP_CODE__ back to the bot.\nThe code is valid 15 minutes.\nFrancois',
     'Telegram bot',
     E'Hello,\nTo connect your account to a @postgsail_bot. Check your email!\n'),
 ('telegram_valid',
     'Telegram bot',
-    E'Hello __RECIPIENT__,\nCongratulations! You have just connect your account to your vessel, @postgsail_bot.\n\nThe PostgSail Team',
+    E'Hello __RECIPIENT__,\nCongratulations! You have just connect your account to your vessel, @postgsail_bot.\nFrancois',
     'Telegram bot!',
-    E'Congratulations!\nYou have just connect your account to your vessel, @postgsail_bot.\n');
+    E'Congratulations!\nYou have just connect your account to your vessel, @postgsail_bot.\n'),
+('no_vessel',
+    'PostgSail add your boat',
+    E'Hello __RECIPIENT__,\nYou created an account on PostgSail but you have not added your boat yet.\nIf you need any assistance, I would be happy to help. It is free and an open-source.\nFrancois',
+    'PostgSail next step',
+    E'Hello,\nYou should create your vessel. Check your email!\n'),
+('no_metadata',
+    'PostgSail connect your boat',
+    E'Hello __RECIPIENT__,\nYou created an account on PostgSail but you have not connected your boat yet.\nIf you need any assistance, I would be happy to help. It is free and an open-source.\nFrancois',
+    'PostgSail next step',
+    E'Hello,\nYou should connect your vessel. Check your email!\n'),
+('no_activity',
+    'PostgSail boat inactivity',
+    E'Hello __RECIPIENT__,\nWe don\'t see any activity on your account, do you need any assistance?\nIf you need any assistance, I would be happy to help. It is free and an open-source.\nFrancois.',
+    'PostgSail inactivity!',
+    E'We detected inactivity. Check your email!\n'),
+('deactivated',
+    'PostgSail account deactivated',
+    E'Hello __RECIPIENT__,\nYour account has been deactivated and all your data has been removed from PostgSail system.',
+    'PostgSail deactivated!',
+    E'We removed your account. Check your email!\n'),
+('grafana',
+    'PostgSail Grafana integration',
+    E'Hello __RECIPIENT__,\nCongratulations! You unlocked Grafana dashboard.\nSee more details at https://app.openplotter.cloud\nHappy sailing!\nFrancois',
+    'PostgSail Grafana!',
+    E'Congratulations!\nYou unlocked Grafana dashboard.\nSee more details at https://app.openplotter.cloud\n'),
+('windy',
+    'PostgSail Windy Weather station',
+    E'Hello __RECIPIENT__,\nCongratulations! Your boat is now a Windy Weather station.\nSee more details at __APP_URL__/windy\nHappy sailing!\nFrancois',
+    'PostgSail Windy!',
+    E'Congratulations!\nYour boat is now a Windy Weather station.\nSee more details at __APP_URL__/windy\n'),
+('alert',
+    'PostgSail Alert',
+    E'Hello __RECIPIENT__,\nWe detected an alert __ALERT__.\nSee more details at __APP_URL__\nStay safe.\nFrancois',
+    'PostgSail Alert!',
+    E'We detected an alert __ALERT__.\n');
 
 ---------------------------------------------------------------------------
 -- Queue handling
@@ -130,12 +165,12 @@ INSERT INTO email_templates VALUES
 
 -- table way
 CREATE TABLE IF NOT EXISTS public.process_queue (
-    id SERIAL PRIMARY KEY,
+    id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
     channel TEXT NOT NULL,
     payload TEXT NOT NULL,
     ref_id TEXT NOT NULL,
-    stored TIMESTAMP WITHOUT TIME ZONE NOT NULL,
-    processed TIMESTAMP WITHOUT TIME ZONE DEFAULT NULL
+    stored TIMESTAMPTZ NOT NULL,
+    processed TIMESTAMPTZ DEFAULT NULL
 );
 -- Description
 COMMENT ON TABLE
@@ -158,7 +193,10 @@ $new_account_entry$ language plpgsql;
 
 create function new_account_otp_validation_entry_fn() returns trigger as $new_account_otp_validation_entry$
 begin
+    -- Add email_otp check only if not from oauth server
+    if (NEW.preferences->>'email_verified')::boolean IS NOT True then
         insert into process_queue (channel, payload, stored, ref_id) values ('email_otp', NEW.email, now(), NEW.user_id);
+    end if;
     return NEW;
 END;
 $new_account_otp_validation_entry$ language plpgsql;
@@ -170,6 +208,14 @@ begin
 END;
 $new_vessel_entry$ language plpgsql;
 
+create function new_vessel_public_fn() returns trigger as $new_vessel_public$
+begin
+    -- Update user settings with a public vessel name
+    perform api.update_user_preferences_fn('{public_vessel}', regexp_replace(NEW.name, '\W+', '', 'g'));
+    return NEW;
+END;
+$new_vessel_public$ language plpgsql;
+
 ---------------------------------------------------------------------------
 -- Tables Application Settings
 -- https://dba.stackexchange.com/questions/27296/storing-application-settings-with-different-datatypes#27297

initdb/02_3_3_signalk_public_functions_helpers.sql

@@ -13,6 +13,23 @@ CREATE SCHEMA IF NOT EXISTS public;
 ---------------------------------------------------------------------------
 -- basic helpers to check type and more
 --
+CREATE OR REPLACE FUNCTION public.isdouble(text) RETURNS BOOLEAN AS
+$isdouble$
+DECLARE x DOUBLE PRECISION;
+BEGIN
+    x = $1::DOUBLE PRECISION;
+    RETURN TRUE;
+EXCEPTION WHEN others THEN
+    RETURN FALSE;
+END;
+$isdouble$
+STRICT
+LANGUAGE plpgsql IMMUTABLE;
+-- Description
+COMMENT ON FUNCTION
+    public.isdouble
+    IS 'Check typeof value is double';
+
 CREATE OR REPLACE FUNCTION public.isnumeric(text) RETURNS BOOLEAN AS
 $isnumeric$
 DECLARE x NUMERIC;
@@ -62,9 +79,9 @@ COMMENT ON FUNCTION
 
 CREATE OR REPLACE FUNCTION public.istimestamptz(text) RETURNS BOOLEAN AS
 $isdate$
-DECLARE x TIMESTAMP WITHOUT TIME ZONE;
+DECLARE x TIMESTAMPTZ;
 BEGIN
-    x = $1::TIMESTAMP WITHOUT TIME ZONE;
+    x = $1::TIMESTAMPTZ;
     RETURN TRUE;
 EXCEPTION WHEN others THEN
     RETURN FALSE;
@@ -75,7 +92,7 @@ LANGUAGE plpgsql IMMUTABLE;
 -- Description
 COMMENT ON FUNCTION
     public.istimestamptz
-    IS 'Check typeof value is TIMESTAMP WITHOUT TIME ZONE';
+    IS 'Check typeof value is TIMESTAMPTZ';
 
 ---------------------------------------------------------------------------
 -- JSON helpers
@@ -134,3 +151,90 @@ $jsonb_diff_val$ LANGUAGE plpgsql;
 COMMENT ON FUNCTION
     public.jsonb_diff_val
     IS 'Compare two jsonb objects';
+
+---------------------------------------------------------------------------
+-- uuid v7 helpers
+--
+-- https://gist.github.com/kjmph/5bd772b2c2df145aa645b837da7eca74
+CREATE OR REPLACE FUNCTION public.timestamp_from_uuid_v7(_uuid uuid)
+RETURNS timestamp without time zone
+LANGUAGE sql
+-- Based off IETF draft, https://datatracker.ietf.org/doc/draft-peabody-dispatch-new-uuid-format/
+IMMUTABLE PARALLEL SAFE STRICT LEAKPROOF
+AS $$
+  SELECT to_timestamp(('x0000' || substr(_uuid::text, 1, 8) || substr(_uuid::text, 10, 4))::bit(64)::bigint::numeric / 1000);
+$$
+;
+-- Description
+COMMENT ON FUNCTION
+    public.timestamp_from_uuid_v7
+    IS 'extract the timestamp from the uuid.';
+
+create or replace function public.uuid_generate_v7()
+returns uuid
+as $$
+begin
+  -- use random v4 uuid as starting point (which has the same variant we need)
+  -- then overlay timestamp
+  -- then set version 7 by flipping the 2 and 1 bit in the version 4 string
+  return encode(
+    set_bit(
+      set_bit(
+        overlay(uuid_send(gen_random_uuid())
+                placing substring(int8send(floor(extract(epoch from clock_timestamp()) * 1000)::bigint) from 3)
+                from 1 for 6
+        ),
+        52, 1
+      ),
+      53, 1
+    ),
+    'hex')::uuid;
+end
+$$
+language plpgsql volatile;
+-- Description
+COMMENT ON FUNCTION
+    public.uuid_generate_v7
+    IS 'Generate UUID v7, Based off IETF draft, https://datatracker.ietf.org/doc/draft-peabody-dispatch-new-uuid-format/';
+
+---------------------------------------------------------------------------
+-- Conversion helpers
+--
+CREATE OR REPLACE FUNCTION public.kelvinToCel(IN temperature NUMERIC)
+RETURNS NUMERIC
+AS $$
+BEGIN
+	RETURN ROUND((((temperature)::numeric - 273.15) * 10) / 10);
+END
+$$
+LANGUAGE plpgsql IMMUTABLE;
+-- Description
+COMMENT ON FUNCTION
+    public.kelvinToCel
+    IS 'convert kelvin To Celsius';
+
+CREATE OR REPLACE FUNCTION public.radiantToDegrees(IN angle NUMERIC)
+RETURNS NUMERIC
+AS $$
+BEGIN
+    RETURN ROUND((((angle)::numeric * 57.2958) * 10) / 10);
+END
+$$
+LANGUAGE plpgsql IMMUTABLE;
+-- Description
+COMMENT ON FUNCTION
+    public.radiantToDegrees
+    IS 'convert radiant To Degrees';
+
+CREATE OR REPLACE FUNCTION public.valToPercent(IN val NUMERIC)
+RETURNS NUMERIC
+AS $$
+BEGIN
+    RETURN (val * 100);
+END
+$$
+LANGUAGE plpgsql IMMUTABLE;
+-- Description
+COMMENT ON FUNCTION
+    public.valToPercent
+    IS 'convert radiant To Degrees';

initdb/02_3_3_signalk_public_functions_py.sql

@@ -17,7 +17,7 @@ CREATE SCHEMA IF NOT EXISTS public;
 --
 DROP FUNCTION IF EXISTS reverse_geocode_py_fn;
 CREATE OR REPLACE FUNCTION reverse_geocode_py_fn(IN geocoder TEXT, IN lon NUMERIC, IN lat NUMERIC,
-    OUT geo_name TEXT)
+    OUT geo JSONB)
 AS $reverse_geocode_py$
     import requests
 
@@ -39,40 +39,57 @@ AS $reverse_geocode_py$
         plpy.error('Error missing parameters')
         return None
 
+    def georeverse(geocoder, lon, lat, zoom="18"):
 	    # Make the request to the geocoder API
 	    # https://operations.osmfoundation.org/policies/nominatim/
-    payload = {"lon": lon, "lat": lat, "format": "jsonv2", "zoom": 18}
-    r = requests.get(url, params=payload)
+	    headers = {"Accept-Language": "en-US,en;q=0.5", "User-Agent": "PostgSail", "From": "xbgmsharp@gmail.com"}
+	    payload = {"lon": lon, "lat": lat, "format": "jsonv2", "zoom": zoom, "accept-language": "en"}
+	    # https://nominatim.org/release-docs/latest/api/Reverse/
+	    r = requests.get(url, headers=headers, params=payload)
 
-    # Return the full address or nothing if not found
-    # Option1: If name is null fallback to address field road,neighbourhood,suburb
-    # Option2: Return the json for future reference like country
+	    # Parse response
+	    # If name is null fallback to address field tags: neighbourhood,suburb
+	    # if none repeat with lower zoom level
 	    if r.status_code == 200 and "name" in r.json():
 	      r_dict = r.json()
+	      #plpy.notice('reverse_geocode_py_fn Parameters [{}] [{}] Response'.format(lon, lat, r_dict))
+	      output = None
+	      country_code = None
+	      if "country_code" in r_dict["address"] and r_dict["address"]["country_code"]:
+	        country_code = r_dict["address"]["country_code"]
 	      if r_dict["name"]:
-        return r_dict["name"]
+	        return { "name": r_dict["name"], "country_code": country_code }
 	      elif "address" in r_dict and r_dict["address"]:
-        if "road" in r_dict["address"] and r_dict["address"]["road"]:
-            return r_dict["address"]["road"]
-        elif "neighbourhood" in r_dict["address"] and r_dict["address"]["neighbourhood"]:
-            return r_dict["address"]["neighbourhood"]
+	        if "neighbourhood" in r_dict["address"] and r_dict["address"]["neighbourhood"]:
+	            return { "name": r_dict["address"]["neighbourhood"], "country_code": country_code }
+	        elif "hamlet" in r_dict["address"] and r_dict["address"]["hamlet"]:
+	            return { "name": r_dict["address"]["hamlet"], "country_code": country_code }
 	        elif "suburb" in r_dict["address"] and r_dict["address"]["suburb"]:
-            return r_dict["address"]["suburb"]
+	            return { "name": r_dict["address"]["suburb"], "country_code": country_code }
 	        elif "residential" in r_dict["address"] and r_dict["address"]["residential"]:
-            return r_dict["address"]["residential"]
+	            return { "name": r_dict["address"]["residential"], "country_code": country_code }
 	        elif "village" in r_dict["address"] and r_dict["address"]["village"]:
-            return r_dict["address"]["village"]
+	            return { "name": r_dict["address"]["village"], "country_code": country_code }
 	        elif "town" in r_dict["address"] and r_dict["address"]["town"]:
-            return r_dict["address"]["town"]
+	            return { "name": r_dict["address"]["town"], "country_code": country_code }
+	        elif "amenity" in r_dict["address"] and r_dict["address"]["amenity"]:
+	            return { "name": r_dict["address"]["amenity"], "country_code": country_code }
 	        else:
-            return 'n/a'
+	            if (zoom == 15):
+	                plpy.notice('georeverse recursive retry with lower zoom than:[{}], Response [{}]'.format(zoom , r.json()))
+	                return { "name": "n/a", "country_code": country_code }
 	            else:
-        return 'n/a'
+	                plpy.notice('georeverse recursive retry with lower zoom than:[{}], Response [{}]'.format(zoom , r.json()))
+	                return georeverse(geocoder, lon, lat, 15)
+	      else:
+	        return { "name": "n/a", "country_code": country_code }
 	    else:
 	      plpy.warning('Failed to received a geo full address %s', r.json())
 	      #plpy.error('Failed to received a geo full address %s', r.json())
-      return 'unknow'
-$reverse_geocode_py$ LANGUAGE plpython3u;
+	      return { "name": "unknown", "country_code": "unknown" }
+
+    return georeverse(geocoder, lon, lat)
+$reverse_geocode_py$ TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
 -- Description
 COMMENT ON FUNCTION 
     public.reverse_geocode_py_fn
@@ -125,6 +142,8 @@ AS $send_email_py$
         email_content = email_content.replace('__OTP_CODE__', _user['otp_code'])
     if 'reset_qs' in _user and _user['reset_qs']:
         email_content = email_content.replace('__RESET_QS__', _user['reset_qs'])
+    if 'alert' in _user and _user['alert']:
+        email_content = email_content.replace('__ALERT__', _user['alert'])
 
     if 'app.url' in app and app['app.url']:
         email_content = email_content.replace('__APP_URL__', app['app.url'])
@@ -157,7 +176,7 @@ AS $send_email_py$
     # Send the message via our own SMTP server.
     try:
         # send your message with credentials specified above
-        with smtplib.SMTP(server_smtp, 25) as server:
+        with smtplib.SMTP(server_smtp, 587) as server:
             if 'app.email_user' in app and app['app.email_user'] \
                 and 'app.email_pass' in app and app['app.email_pass']:
                 server.starttls()
@@ -214,6 +233,8 @@ AS $send_pushover_py$
         pushover_message = pushover_message.replace('__BOAT__', _user['boat'])
     if 'badge' in _user and _user['badge']:
         pushover_message = pushover_message.replace('__BADGE_NAME__', _user['badge'])
+    if 'alert' in _user and _user['alert']:
+        pushover_message = pushover_message.replace('__ALERT__', _user['alert'])
 
     if 'app.url' in app and app['app.url']:
         pushover_message = pushover_message.replace('__APP_URL__', app['app.url'])
@@ -290,6 +311,8 @@ AS $send_telegram_py$
         telegram_message = telegram_message.replace('__BOAT__', _user['boat'])
     if 'badge' in _user and _user['badge']:
         telegram_message = telegram_message.replace('__BADGE_NAME__', _user['badge'])
+    if 'alert' in _user and _user['alert']:
+        telegram_message = telegram_message.replace('__ALERT__', _user['alert'])
 
     if 'app.url' in app and app['app.url']:
         telegram_message = telegram_message.replace('__APP_URL__', app['app.url'])
@@ -340,6 +363,10 @@ AS $urlencode_py$
     import urllib.parse
     return urllib.parse.quote(uri, safe="");
 $urlencode_py$ LANGUAGE plpython3u IMMUTABLE STRICT;
+-- Description
+COMMENT ON FUNCTION
+    public.urlencode_py_fn
+    IS 'python url encode using plpython3u';
 
 ---------------------------------------------------------------------------
 -- python
@@ -357,16 +384,14 @@ AS $reverse_geoip_py$
     url = f'https://ipapi.co/{_ip}/json/'
     r = requests.get(url)
     #print(r.text)
-    # Return something boolean?
     #plpy.notice('IP [{}] [{}]'.format(_ip, r.status_code))
     if r.status_code == 200:
         #plpy.notice('Got [{}] [{}]'.format(r.text, r.status_code))
-        return r.text;
+        return r.json()
     else:
         plpy.error('Failed to get ip details')
-    return '{}'
-$reverse_geoip_py$ LANGUAGE plpython3u;
-
+    return {}
+$reverse_geoip_py$ IMMUTABLE strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
 -- Description
 COMMENT ON FUNCTION
     public.reverse_geoip_py_fn
@@ -415,4 +440,420 @@ IMMUTABLE STRICT;
 -- Description
 COMMENT ON FUNCTION
     public.geojson_py_fn
-    IS 'Parse geojson using plpython3u (should be done in PGSQL)';
+    IS 'Parse geojson using plpython3u (should be done in PGSQL), deprecated';
+
+DROP FUNCTION IF EXISTS overpass_py_fn;
+CREATE OR REPLACE FUNCTION overpass_py_fn(IN lon NUMERIC, IN lat NUMERIC,
+    OUT geo JSONB) RETURNS JSONB
+AS $overpass_py$
+    """
+    Return https://overpass-turbo.eu seamark details within 400m
+    https://overpass-turbo.eu/s/1EaG
+    https://wiki.openstreetmap.org/wiki/Key:seamark:type
+    """
+    import requests
+    import json
+    import urllib.parse
+
+    headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com'}
+    payload = """
+    [out:json][timeout:20];
+    is_in({0},{1})->.result_areas;
+    (
+      area.result_areas["seamark:type"~"(mooring|harbour)"][~"^seamark:.*:category$"~"."];
+      area.result_areas["leisure"="marina"][~"name"~"."];
+    );
+    out tags;
+    nwr(around:400.0,{0},{1})->.all;
+    (
+        nwr.all["seamark:type"~"(mooring|harbour)"][~"^seamark:.*:category$"~"."];
+        nwr.all["seamark:type"~"(anchorage|anchor_berth|berth)"];
+        nwr.all["leisure"="marina"];
+        nwr.all["natural"~"(bay|beach)"];
+    );
+    out tags;
+    """.format(lat, lon)
+    data = urllib.parse.quote(payload, safe="");
+    url = f'https://overpass-api.de/api/interpreter?data={data}'.format(data)
+    r = requests.get(url, headers)
+    #print(r.text)
+    #plpy.notice(url)
+    plpy.notice('overpass-api coord lon[{}] lat[{}] [{}]'.format(lon, lat, r.status_code))
+    if r.status_code == 200 and "elements" in r.json():
+        r_dict = r.json()
+        plpy.notice('overpass-api Got [{}]'.format(r_dict["elements"]))
+        if r_dict["elements"]:
+            if "tags" in r_dict["elements"][0] and r_dict["elements"][0]["tags"]:
+                return r_dict["elements"][0]["tags"]; # return the first element
+        return {}
+    else:
+        plpy.notice('overpass-api Failed to get overpass-api details')
+    return {}
+$overpass_py$ IMMUTABLE strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.overpass_py_fn
+    IS 'Return https://overpass-turbo.eu seamark details within 400m using plpython3u';
+
+---------------------------------------------------------------------------
+-- Provision Grafana SQL
+--
+CREATE OR REPLACE FUNCTION grafana_py_fn(IN _v_name TEXT, IN _v_id TEXT,
+    IN _u_email TEXT, IN app JSONB) RETURNS VOID
+AS $grafana_py$
+	"""
+	https://grafana.com/docs/grafana/latest/developers/http_api/
+	Create organization base on vessel name
+	Create user base on user email
+	Add user to organization
+	Add data_source to organization
+	Add dashboard to organization
+    Update organization preferences
+	"""
+	import requests
+	import json
+	import re
+
+	grafana_uri = None
+	if 'app.grafana_admin_uri' in app and app['app.grafana_admin_uri']:
+		grafana_uri = app['app.grafana_admin_uri']
+	else:
+		plpy.error('Error no grafana_admin_uri defined, check app settings')
+		return None
+
+	b_name = None
+	if not _v_name:
+		b_name = _v_id
+	else:
+		b_name = _v_name
+
+	# add vessel org
+	headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com',
+	'Accept': 'application/json', 'Content-Type': 'application/json'}
+	path = 'api/orgs'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	data_dict = {'name':b_name}
+	data = json.dumps(data_dict)
+	r = requests.post(url, data=data, headers=headers)
+	#print(r.text)
+	#plpy.notice(r.json())
+	if r.status_code == 200 and "orgId" in r.json():
+		org_id = r.json()['orgId']
+	else:
+		plpy.error('Error grafana add vessel org %', r.json())
+		return None
+
+	# add user to vessel org
+	path = 'api/admin/users'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	data_dict = {'orgId':org_id, 'email':_u_email, 'password':'asupersecretpassword'}
+	data = json.dumps(data_dict)
+	r = requests.post(url, data=data, headers=headers)
+	#print(r.text)
+	#plpy.notice(r.json())
+	if r.status_code == 200 and "id" in r.json():
+		user_id = r.json()['id']
+	else:
+		plpy.error('Error grafana add user to vessel org')
+		return
+
+	# read data_source
+	path = 'api/datasources/1'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	r = requests.get(url, headers=headers)
+	#print(r.text)
+	#plpy.notice(r.json())
+	data_source = r.json()
+	data_source['id'] = 0
+	data_source['orgId'] = org_id
+	data_source['uid'] = "ds_" + _v_id
+	data_source['name'] = "ds_" + _v_id
+	data_source['secureJsonData'] = {}
+	data_source['secureJsonData']['password'] = 'password'
+	data_source['readOnly'] = True
+	del data_source['secureJsonFields']
+
+	# add data_source to vessel org
+	path = 'api/datasources'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	data = json.dumps(data_source)
+	headers['X-Grafana-Org-Id'] = str(org_id)
+	r = requests.post(url, data=data, headers=headers)
+	#plpy.notice(r.json())
+	del headers['X-Grafana-Org-Id']
+	if r.status_code != 200 and "id" not in r.json():
+		plpy.error('Error grafana add data_source to vessel org')
+		return
+
+	dashboards_tpl = [ 'pgsail_tpl_electrical', 'pgsail_tpl_logbook', 'pgsail_tpl_monitor', 'pgsail_tpl_rpi', 'pgsail_tpl_solar', 'pgsail_tpl_weather', 'pgsail_tpl_home']
+	for dashboard in dashboards_tpl:
+		# read dashboard template by uid
+		path = 'api/dashboards/uid'
+		url = f'{grafana_uri}/{path}/{dashboard}'.format(grafana_uri,path,dashboard)
+		if 'X-Grafana-Org-Id' in headers:
+			del headers['X-Grafana-Org-Id']
+		r = requests.get(url, headers=headers)
+		#plpy.notice(r.json())
+		if r.status_code != 200 and "id" not in r.json():
+			plpy.error('Error grafana read dashboard template')
+			return
+		new_dashboard = r.json()
+		del new_dashboard['meta']
+		new_dashboard['dashboard']['version'] = 0
+		new_dashboard['dashboard']['id'] = 0
+		new_uid = re.sub(r'pgsail_tpl_(.*)', r'postgsail_\1', new_dashboard['dashboard']['uid'])
+		new_dashboard['dashboard']['uid'] = f'{new_uid}_{_v_id}'.format(new_uid,_v_id)
+		# add dashboard to vessel org
+		path = 'api/dashboards/db'
+		url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+		data = json.dumps(new_dashboard)
+		new_data = data.replace('PCC52D03280B7034C', data_source['uid'])
+		headers['X-Grafana-Org-Id'] = str(org_id)
+		r = requests.post(url, data=new_data, headers=headers)
+		#plpy.notice(r.json())
+		if r.status_code != 200 and "id" not in r.json():
+			plpy.error('Error grafana add dashboard to vessel org')
+			return
+
+	# Update Org Prefs
+	path = 'api/org/preferences'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	home_dashboard = {}
+	home_dashboard['timezone'] = 'utc'
+	home_dashboard['homeDashboardUID'] = f'postgsail_home_{_v_id}'.format(_v_id)
+	data = json.dumps(home_dashboard)
+	headers['X-Grafana-Org-Id'] = str(org_id)
+	r = requests.patch(url, data=data, headers=headers)
+	#plpy.notice(r.json())
+	if r.status_code != 200:
+		plpy.error('Error grafana update org preferences')
+		return
+
+	plpy.notice('Done')
+$grafana_py$ TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.grafana_py_fn
+    IS 'Grafana Organization,User,data_source,dashboards provisioning via HTTP API using plpython3u';
+
+-- https://stackoverflow.com/questions/65517230/how-to-set-user-attribute-value-in-keycloak-using-api
+DROP FUNCTION IF EXISTS keycloak_py_fn;
+CREATE OR REPLACE FUNCTION keycloak_py_fn(IN user_id TEXT, IN vessel_id TEXT,
+    IN app JSONB) RETURNS JSONB
+AS $keycloak_py$
+    """
+    Add vessel_id user attribute to keycloak user {user_id}
+    """
+    import requests
+    import json
+    import urllib.parse
+
+    safe_uri = host = user = pwd = None
+    if 'app.keycloak_uri' in app and app['app.keycloak_uri']:
+        #safe_uri = urllib.parse.quote(app['app.keycloak_uri'], safe=':/?&=')
+        _ = urllib.parse.urlparse(app['app.keycloak_uri'])
+        host = _.netloc.split('@')[-1]
+        user = _.netloc.split(':')[0]
+        pwd = _.netloc.split(':')[1].split('@')[0]
+    else:
+        plpy.error('Error no keycloak_uri defined, check app settings')
+        return None
+
+    if not host or not user or not pwd:
+        plpy.error('Error parsing keycloak_uri, check app settings')
+        return None
+
+    _headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com'}
+    _payload = {'client_id':'admin-cli','grant_type':'password','username':user,'password':pwd}
+    url = f'{_.scheme}://{host}/realms/master/protocol/openid-connect/token'.format(_.scheme, host)
+    r = requests.post(url, headers=_headers, data=_payload, timeout=(5, 60))
+    #print(r.text)
+    #plpy.notice(url)
+    if r.status_code == 200 and 'access_token' in r.json():
+        response = r.json()
+        plpy.notice(response)
+        _headers['Authorization'] = 'Bearer '+ response['access_token']
+        _headers['Content-Type'] = 'application/json'
+        _payload = { 'attributes': {'vessel_id': vessel_id} }
+        url = f'{keycloak_uri}/admin/realms/postgsail/users/{user_id}'.format(keycloak_uri,user_id)
+        #plpy.notice(url)
+        #plpy.notice(_payload)
+        data = json.dumps(_payload)
+        r = requests.put(url, headers=_headers, data=data, timeout=(5, 60))
+        if r.status_code != 204:
+            plpy.notice("Error updating user: {status} [{text}]".format(
+                status=r.status_code, text=r.text))
+            return None
+        else:
+            plpy.notice("Updated user : {user} [{text}]".format(user=user_id, text=r.text))
+    else:
+        plpy.notice(f'Error getting admin access_token: {status} [{text}]'.format(
+                status=r.status_code, text=r.text))
+    return None
+$keycloak_py$ strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.keycloak_py_fn
+    IS 'Set oauth user attribute into keycloak using plpython3u';
+
+DROP FUNCTION IF EXISTS keycloak_auth_py_fn;
+CREATE OR REPLACE FUNCTION keycloak_auth_py_fn(IN _v_id TEXT,
+    IN _user JSONB, IN app JSONB) RETURNS JSONB
+AS $keycloak_auth_py$
+    """
+    Add keycloak user
+    """
+    import requests
+    import json
+    import urllib.parse
+
+    safe_uri = host = user = pwd = None
+    if 'app.keycloak_uri' in app and app['app.keycloak_uri']:
+        #safe_uri = urllib.parse.quote(app['app.keycloak_uri'], safe=':/?&=')
+        _ = urllib.parse.urlparse(app['app.keycloak_uri'])
+        host = _.netloc.split('@')[-1]
+        user = _.netloc.split(':')[0]
+        pwd = _.netloc.split(':')[1].split('@')[0]
+    else:
+        plpy.error('Error no keycloak_uri defined, check app settings')
+        return none
+
+    if not host or not user or not pwd:
+        plpy.error('Error parsing keycloak_uri, check app settings')
+        return None
+
+    if not 'email' in _user and _user['email']:
+        plpy.error('Error parsing user email, check user settings')
+        return none
+
+    if not _v_id:
+        plpy.error('Error parsing vessel_id')
+        return none
+
+    _headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com'}
+    _payload = {'client_id':'admin-cli','grant_type':'password','username':user,'password':pwd}
+    url = f'{_.scheme}://{host}/realms/master/protocol/openid-connect/token'.format(_.scheme, host)
+    r = requests.post(url, headers=_headers, data=_payload, timeout=(5, 60))
+    #print(r.text)
+    #plpy.notice(url)
+    if r.status_code == 200 and 'access_token' in r.json():
+        response = r.json()
+        #plpy.notice(response)
+        _headers['Authorization'] = 'Bearer '+ response['access_token']
+        _headers['Content-Type'] = 'application/json'
+        url = f'{_.scheme}://{host}/admin/realms/postgsail/users'.format(_.scheme, host)
+        _payload = {
+            "enabled": "true",
+            "email": _user['email'],
+            "firstName": _user['recipient'],
+            "attributes": {"vessel_id": _v_id},
+            "emailVerified": True,
+            "requiredActions":["UPDATE_PROFILE", "UPDATE_PASSWORD"]
+        }
+        #plpy.notice(_payload)
+        data = json.dumps(_payload)
+        r = requests.post(url, headers=_headers, data=data, timeout=(5, 60))
+        if r.status_code != 201:
+            #print("Error creating user: {status}".format(status=r.status_code))
+            plpy.error(f'Error creating user: {user} {status}'.format(user=_payload['email'], status=r.status_code))
+            return None
+        else:
+            #print("Created user : {u}]".format(u=_payload['email']))
+            plpy.notice('Created user : {u} {t}, {l}'.format(u=_payload['email'], t=r.text, l=r.headers['location']))
+            user_url = "{user_url}/execute-actions-email".format(user_url=r.headers['location'])
+            _payload = ["UPDATE_PASSWORD"]
+            #plpy.notice(_payload)
+            data = json.dumps(_payload)
+            r = requests.put(user_url, headers=_headers, data=data, timeout=(5, 60))
+            if r.status_code != 204:
+              plpy.error('Error execute-actions-email: {u} {s}'.format(u=_user['email'], s=r.status_code))
+            else:
+              plpy.notice('execute-actions-email: {u} {s}'.format(u=_user['email'], s=r.status_code))
+            return None
+    else:
+        plpy.error(f'Error getting admin access_token: {status}'.format(status=r.status_code))
+    return None
+$keycloak_auth_py$ strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.keycloak_auth_py_fn
+    IS 'Create an oauth user into keycloak using plpython3u';
+
+CREATE OR REPLACE FUNCTION windy_pws_py_fn(IN metric JSONB,
+    IN _user JSONB, IN app JSONB) RETURNS JSONB
+AS $windy_pws_py$
+    """
+    Send environment data from boat instruments to Windy as a Personal Weather Station (PWS)
+    https://community.windy.com/topic/8168/report-your-weather-station-data-to-windy
+    """
+    import requests
+    import json
+    import decimal
+
+    if not 'app.windy_apikey' in app and not app['app.windy_apikey']:
+        plpy.error('Error no windy_apikey defined, check app settings')
+        return none
+    if not 'station' in metric and not metric['station']:
+        plpy.error('Error no metrics defined')
+        return none
+    if not 'temp' in metric and not metric['temp']:
+        plpy.error('Error no metrics defined')
+        return none
+    if not _user:
+        plpy.error('Error no user defined, check user settings')
+        return none
+
+    _headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com', 'Content-Type': 'application/json'}
+    _payload = {
+        'stations': [
+            { 'station': int(decimal.Decimal(metric['station'])),
+            'name': metric['name'],
+            'shareOption': 'Open',
+            'type': 'SignalK PostgSail Plugin',
+            'provider': 'PostgSail',
+            'url': 'https://iot.openplotter.cloud/{name}/monitoring'.format(name=metric['name']),
+            'lat': float(decimal.Decimal(metric['lat'])),
+            'lon': float(decimal.Decimal(metric['lon'])),
+            'elevation': 1 }
+        ],
+        'observations': [
+            { 'station': int(decimal.Decimal(metric['station'])),
+            'temp': float(decimal.Decimal(metric['temp'])),
+            'wind': round(float(decimal.Decimal(metric['wind']))),
+            'gust': round(float(decimal.Decimal(metric['wind']))),
+            'winddir': int(decimal.Decimal(metric['winddir'])),
+            'pressure': int(decimal.Decimal(metric['pressure'])),
+            'rh': float(decimal.Decimal(metric['rh'])) }
+    ]}
+    #print(_payload)
+    #plpy.notice(_payload)
+    data = json.dumps(_payload)
+    api_url = 'https://stations.windy.com/pws/update/{api_key}'.format(api_key=app['app.windy_apikey'])
+    r = requests.post(api_url, data=data, headers=_headers, timeout=(5, 60))
+    #print(r.text)
+    #plpy.notice(api_url)
+    if r.status_code == 200:
+        #print('Data sent successfully!')
+        plpy.notice('Data sent successfully to Windy!')
+        #plpy.notice(api_url)
+        if not 'windy' in _user['settings']:
+	        api_url = 'https://stations.windy.com/pws/station/{api_key}/{station}'.format(api_key=app['app.windy_apikey'], station=metric['station'])
+		    #print(r.text)
+		    #plpy.notice(api_url)
+	        r = requests.get(api_url, timeout=(5, 60))
+	        if r.status_code == 200:
+	            #print('Windy Personal Weather Station created successfully in Windy Stations!')
+	            plpy.notice('Windy Personal Weather Station created successfully in Windy Stations!')
+	            return r.json()
+	        else:
+	            plpy.error(f'Failed to gather PWS details. Status code: {r.status_code}')
+    else:
+        plpy.error(f'Failed to send data. Status code: {r.status_code}')
+        #print(f'Failed to send data. Status code: {r.status_code}')
+        #print(r.text)
+    return {}
+$windy_pws_py$ strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.windy_pws_py_fn
+    IS 'Forward vessel data to Windy as a Personal Weather Station using plpython3u';

initdb/02_4_signalk_auth.sql

@@ -21,17 +21,18 @@ CREATE EXTENSION IF NOT EXISTS "pgcrypto"; -- provides cryptographic functions
 
 DROP TABLE IF EXISTS auth.accounts CASCADE;
 CREATE TABLE IF NOT EXISTS auth.accounts (
-  userid        UUID NOT NULL UNIQUE DEFAULT uuid_generate_v4(),
+  id            INT UNIQUE GENERATED ALWAYS AS IDENTITY,
+  --id            TEXT NOT NULL UNIQUE DEFAULT uuid_generate_v7(),
   user_id       TEXT NOT NULL UNIQUE DEFAULT RIGHT(gen_random_uuid()::text, 12),
-  email         CITEXT primary key check ( email ~* '^.+@.+\..+$' ),
-  first         text not null check (length(pass) < 512),
-  last          text not null check (length(pass) < 512),
-  pass          text not null check (length(pass) < 512),
-  role          name not null check (length(role) < 512),
+  email         CITEXT PRIMARY KEY CHECK ( email ~* '^.+@.+\..+$' ),
+  first         TEXT NOT NULL CHECK (length(pass) < 512),
+  last          TEXT NOT NULL CHECK (length(pass) < 512),
+  pass          TEXT NOT NULL CHECK (length(pass) < 512),
+  role          name NOT NULL CHECK (length(role) < 512),
   preferences   JSONB NULL DEFAULT '{"email_notifications":true}',
-  created_at    TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT NOW(),
-  updated_at    TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT NOW(),
-  connected_at    TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT NOW(),
+  created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  connected_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
   CONSTRAINT valid_email CHECK (length(email) > 5), -- Enforce at least 5 char, eg: a@b.io
   CONSTRAINT valid_first CHECK (length(first) > 1),
   CONSTRAINT valid_last CHECK (length(last) > 1),
@@ -42,9 +43,9 @@ COMMENT ON TABLE
     auth.accounts
     IS 'users account table';
 -- Indexes
-CREATE INDEX accounts_role_idx ON auth.accounts (role);
-CREATE INDEX accounts_preferences_idx ON auth.accounts using GIN (preferences);
-CREATE INDEX accounts_userid_idx ON auth.accounts (userid);
+CREATE INDEX accounts_preferences_idx ON auth.accounts USING GIN (preferences);
+COMMENT ON COLUMN auth.accounts.first IS 'User first name with CONSTRAINT CHECK';
+COMMENT ON COLUMN auth.accounts.last IS 'User last name with CONSTRAINT CHECK';
 
 CREATE TRIGGER accounts_moddatetime
 	BEFORE UPDATE ON auth.accounts
@@ -60,24 +61,20 @@ CREATE TABLE IF NOT EXISTS auth.vessels (
   vessel_id   TEXT NOT NULL UNIQUE DEFAULT RIGHT(gen_random_uuid()::text, 12),
 --  user_id       TEXT NOT NULL REFERENCES auth.accounts(user_id) ON DELETE RESTRICT,
   owner_email CITEXT PRIMARY KEY REFERENCES auth.accounts(email) ON DELETE RESTRICT,
---  mmsi		    TEXT UNIQUE, -- Should be a numeric range between 100000000 and 800000000.
   mmsi        NUMERIC UNIQUE, -- MMSI can be optional but if present must be a valid one and unique
   name        TEXT NOT NULL CHECK (length(name) >= 3 AND length(name) < 512),
---  pass        text not null check (length(pass) < 512), -- unused
   role        name not null check (length(role) < 512),
-  created_at  TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT NOW(),
-  updated_at  TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT NOW()
---  CONSTRAINT valid_length_mmsi CHECK (length(mmsi) < 10 OR length(mmsi) = 0)
+  created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
   CONSTRAINT valid_range_mmsi CHECK (mmsi > 100000000 AND mmsi < 800000000)
 );
 -- Description
 COMMENT ON TABLE
     auth.vessels
     IS 'vessels table link to accounts email user_id column';
--- Indexes
-CREATE INDEX vessels_role_idx ON auth.vessels (role);
-CREATE INDEX vessels_name_idx ON auth.vessels (name);
-CREATE INDEX vessels_vesselid_idx ON auth.vessels (vessel_id);
+COMMENT ON COLUMN
+    auth.vessels.mmsi
+    IS 'MMSI can be optional but if present must be a valid one and unique but must be in numeric range between 100000000 and 800000000';
 
 CREATE TRIGGER vessels_moddatetime
   BEFORE UPDATE ON auth.vessels
@@ -88,6 +85,32 @@ COMMENT ON TRIGGER vessels_moddatetime
   ON auth.vessels
   IS 'Automatic update of updated_at on table modification';
 
+CREATE TABLE auth.users (
+  id            NAME PRIMARY KEY DEFAULT current_setting('request.jwt.claims', true)::json->>'sub',
+  email         NAME NOT NULL DEFAULT current_setting('request.jwt.claims', true)::json->>'email',
+  user_id       TEXT NOT NULL UNIQUE DEFAULT RIGHT(gen_random_uuid()::text, 12),
+  first         TEXT NOT NULL DEFAULT current_setting('request.jwt.claims', true)::json->>'given_name',
+  last          TEXT NOT NULL DEFAULT current_setting('request.jwt.claims', true)::json->>'family_name',
+  role          NAME NOT NULL DEFAULT 'user_role' CHECK (length(role) < 512),
+  preferences   JSONB NULL DEFAULT '{"email_notifications":true, "email_valid": true, "email_verified": true}',
+  created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  connected_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+-- Description
+COMMENT ON TABLE
+    auth.users
+    IS 'Keycloak Oauth user, map user details from access token';
+
+CREATE TRIGGER user_moddatetime
+  BEFORE UPDATE ON auth.users
+  FOR EACH ROW
+  EXECUTE PROCEDURE moddatetime (updated_at);
+-- Description
+COMMENT ON TRIGGER user_moddatetime
+  ON auth.users
+  IS 'Automatic update of updated_at on table modification';
+
 create or replace function
 auth.check_role_exists() returns trigger as $$
 begin
@@ -106,12 +129,26 @@ create constraint trigger ensure_user_role_exists
   after insert or update on auth.accounts
   for each row
   execute procedure auth.check_role_exists();
+-- Description
+COMMENT ON TRIGGER ensure_user_role_exists
+  ON auth.accounts
+  IS 'ensure user role exists';
+
 -- trigger add queue new account
 CREATE TRIGGER new_account_entry AFTER INSERT ON auth.accounts
     FOR EACH ROW EXECUTE FUNCTION public.new_account_entry_fn();
+-- Description
+COMMENT ON TRIGGER new_account_entry
+  ON auth.accounts
+  IS 'Add new account in process_queue for further processing';
+
 -- trigger add queue new account OTP validation
 CREATE TRIGGER new_account_otp_validation_entry AFTER INSERT ON auth.accounts
     FOR EACH ROW EXECUTE FUNCTION public.new_account_otp_validation_entry_fn();
+-- Description
+COMMENT ON TRIGGER new_account_otp_validation_entry
+  ON auth.accounts
+  IS 'Add new account OTP validation in process_queue for further processing';
 
 -- trigger check role on vessel
 drop trigger if exists ensure_vessel_role_exists on auth.vessels;
@@ -122,6 +159,18 @@ create constraint trigger ensure_vessel_role_exists
 -- trigger add queue new vessel
 CREATE TRIGGER new_vessel_entry AFTER INSERT ON auth.vessels
     FOR EACH ROW EXECUTE FUNCTION public.new_vessel_entry_fn();
+-- Description
+COMMENT ON TRIGGER new_vessel_entry
+  ON auth.vessels
+  IS 'Add new vessel in process_queue for further processing';
+
+-- trigger add new vessel name as public_vessel user configuration
+CREATE TRIGGER new_vessel_public AFTER INSERT ON auth.vessels
+    FOR EACH ROW EXECUTE FUNCTION public.new_vessel_public_fn();
+-- Description
+COMMENT ON TRIGGER new_vessel_public
+  ON auth.vessels
+  IS 'Add new vessel name as public_vessel user configuration';
 
 create or replace function
 auth.encrypt_pass() returns trigger as $$
@@ -179,7 +228,10 @@ begin
   -- check email and password
   select auth.user_role(email, pass) into _role;
   if _role is null then
-    raise invalid_password using message = 'invalid user or password';
+    -- HTTP/403
+    --raise invalid_password using message = 'invalid user or password';
+    -- HTTP/401
+    raise insufficient_privilege using message = 'invalid user or password';
   end if;
 
   -- Get app_jwt_secret
@@ -236,6 +288,96 @@ begin
 end;
 $$ language plpgsql security definer;
 
+---------------------------------------------------------------------------
+-- API account Oauth functions
+--
+-- oauth is on your exposed schema
+create or replace function
+api.oauth() returns void as $$
+declare
+  _exist boolean;
+begin
+  -- Ensure we have the required key/value in the access token
+  if current_setting('request.jwt.claims', true)::json->>'sub' is null OR
+     current_setting('request.jwt.claims', true)::json->>'email' is null THEN
+    return;
+  end if;
+  -- check email exist
+  select exists( select email from auth.users
+     where id = current_setting('request.jwt.claims', true)::json->>'sub'
+    ) INTO _exist;
+  if NOT FOUND then
+	  RAISE WARNING 'Register new oauth user email:[%]', current_setting('request.jwt.claims', true)::json->>'email';
+    -- insert new user, default value from the oauth access token
+	  INSERT INTO auth.users (role, preferences)
+	    VALUES ('user_role', '{"email_notifications":true, "email_valid": true, "email_verified": true}');
+  end if;
+end;
+$$ language plpgsql security definer;
+-- Description
+COMMENT ON FUNCTION
+    api.oauth
+    IS 'openid/oauth user register entry point';
+
+create or replace function
+api.oauth_vessel(in _mmsi text, in _name text) returns void as $$
+declare
+  _exist boolean;
+  vessel_name text := _name;
+  vessel_mmsi text := _mmsi;
+  _vessel_id text := null;
+  vessel_rec record;
+  app_settings jsonb;
+  _user_id text := null;
+begin
+  RAISE WARNING 'oauth_vessel:[%]', current_setting('user.email', true);
+  RAISE WARNING 'oauth_vessel:[%]', current_setting('request.jwt.claims', true)::json->>'email';
+  -- Ensure we have the required key/value in the access token
+  if current_setting('request.jwt.claims', true)::json->>'sub' is null OR
+     current_setting('request.jwt.claims', true)::json->>'email' is null THEN
+    return;
+  end if;
+
+  -- check email exist
+  select exists( select email from auth.accounts
+     where email = current_setting('request.jwt.claims', true)::json->>'email'
+    ) INTO _exist;
+  if _exist is False then
+    RAISE WARNING 'Register new oauth user email:[%]', current_setting('request.jwt.claims', true)::json->>'email';
+    -- insert new user, default value from the oauth access token
+    INSERT INTO auth.users VALUES(DEFAULT) RETURNING user_id INTO _user_id;
+    -- insert new user to account table from the oauth access token
+    INSERT INTO auth.accounts (email, first, last, pass, user_id, role, preferences)
+      VALUES (current_setting('request.jwt.claims', true)::json->>'email',
+      current_setting('request.jwt.claims', true)::json->>'given_name',
+      current_setting('request.jwt.claims', true)::json->>'family_name',
+      current_setting('request.jwt.claims', true)::json->>'sub',
+      _user_id, 'user_role', '{"email_notifications":true, "email_valid": true, "email_verified": true}');
+  end if;
+
+  IF public.isnumeric(vessel_mmsi) IS False THEN
+    vessel_mmsi = NULL;
+  END IF;
+  -- check vessel exist
+  SELECT * INTO vessel_rec
+    FROM auth.vessels vessel
+    WHERE vessel.owner_email = current_setting('request.jwt.claims', true)::json->>'email';
+  IF vessel_rec IS NULL THEN
+      RAISE WARNING 'Register new vessel name:[%] mmsi:[%] for [%]', vessel_name, vessel_mmsi, current_setting('request.jwt.claims', true)::json->>'email';
+      INSERT INTO auth.vessels (owner_email, mmsi, name, role)
+        VALUES (current_setting('request.jwt.claims', true)::json->>'email', vessel_mmsi::NUMERIC, vessel_name, 'vessel_role') RETURNING vessel_id INTO _vessel_id;
+      -- Gather url from app settings
+      app_settings := get_app_settings_fn();
+      -- set oauth user vessel_id attributes for token generation
+      PERFORM keycloak_py_fn(current_setting('request.jwt.claims', true)::json->>'sub'::TEXT, _vessel_id::TEXT, app_settings);
+  END IF;
+end;
+$$ language plpgsql security definer;
+-- Description
+COMMENT ON FUNCTION
+    api.oauth_vessel
+    IS 'user and vessel register entry point from signalk plugin';
+
 ---------------------------------------------------------------------------
 -- API vessel helper functions
 -- register_vessel should be on your exposed schema

initdb/02_5_signalk_api_deps.sql

@@ -11,7 +11,7 @@ select current_database();
 -- Link auth.vessels with api.metadata
 --ALTER TABLE api.metadata ADD vessel_id TEXT NOT NULL REFERENCES auth.vessels(vessel_id) ON DELETE RESTRICT;
 ALTER TABLE api.metadata ADD FOREIGN KEY (vessel_id) REFERENCES auth.vessels(vessel_id) ON DELETE RESTRICT;
-COMMENT ON COLUMN api.metadata.vessel_id IS 'Link auth.vessels with api.metadata';
+COMMENT ON COLUMN api.metadata.vessel_id IS 'Link auth.vessels with api.metadata via FOREIGN KEY and REFERENCES';
 
 -- Link auth.vessels with auth.accounts
 --ALTER TABLE auth.vessels ADD user_id TEXT NOT NULL REFERENCES auth.accounts(user_id) ON DELETE RESTRICT;
@@ -20,12 +20,21 @@ COMMENT ON COLUMN api.metadata.vessel_id IS 'Link auth.vessels with api.metadata
 
 -- REFERENCE ship type with AIS type ?
 -- REFERENCE mmsi MID with country ?
-
+ALTER TABLE api.logbook ADD FOREIGN KEY (_from_moorage_id) REFERENCES api.moorages(id) ON DELETE RESTRICT;
+COMMENT ON COLUMN api.logbook._from_moorage_id IS 'Link api.moorages with api.logbook via FOREIGN KEY and REFERENCES';
+ALTER TABLE api.logbook ADD FOREIGN KEY (_to_moorage_id) REFERENCES api.moorages(id) ON DELETE RESTRICT;
+COMMENT ON COLUMN api.logbook._to_moorage_id IS 'Link api.moorages with api.logbook via FOREIGN KEY and REFERENCES';
+ALTER TABLE api.stays ADD FOREIGN KEY (moorage_id) REFERENCES api.moorages(id) ON DELETE RESTRICT;
+COMMENT ON COLUMN api.stays.moorage_id IS 'Link api.moorages with api.stays via FOREIGN KEY and REFERENCES';
+ALTER TABLE api.stays ADD FOREIGN KEY (stay_code) REFERENCES api.stays_at(stay_code) ON DELETE RESTRICT;
+COMMENT ON COLUMN api.stays.stay_code IS 'Link api.stays_at with api.stays via FOREIGN KEY and REFERENCES';
+ALTER TABLE api.moorages ADD FOREIGN KEY (stay_code) REFERENCES api.stays_at(stay_code) ON DELETE RESTRICT;
+COMMENT ON COLUMN api.moorages.stay_code IS 'Link api.stays_at with api.moorages via FOREIGN KEY and REFERENCES';
 
 -- List vessel
 --TODO add geojson with position
 DROP VIEW IF EXISTS api.vessels_view;
-CREATE OR REPLACE VIEW api.vessels_view AS
+CREATE OR REPLACE VIEW api.vessels_view WITH (security_invoker=true,security_barrier=true) AS
     WITH metadata AS (
         SELECT COALESCE(
             (SELECT  m.time
@@ -37,8 +46,10 @@ CREATE OR REPLACE VIEW api.vessels_view AS
     SELECT
         v.name as name,
         v.mmsi as mmsi,
-        v.created_at::timestamp(0) as created_at,
-        m.last_contact as last_contact
+        v.created_at as created_at,
+        m.last_contact as last_contact,
+        ((NOW() AT TIME ZONE 'UTC' - m.last_contact::TIMESTAMPTZ) > INTERVAL '70 MINUTES') as offline,
+        (NOW() AT TIME ZONE 'UTC' - m.last_contact::TIMESTAMPTZ) as duration
     FROM auth.vessels v, metadata m
     WHERE v.owner_email = current_setting('user.email');
 -- Description
@@ -63,7 +74,27 @@ $has_vessel$ language plpgsql security definer;
 -- Description
 COMMENT ON FUNCTION
     public.has_vessel_fn
-    IS 'Expose has vessel to API';
+    IS 'Check if user has a vessel register';
+
+DROP FUNCTION IF EXISTS public.has_vessel_metadata_fn;
+CREATE OR REPLACE FUNCTION public.has_vessel_metadata_fn() RETURNS BOOLEAN
+AS $has_vessel_metadata$
+	DECLARE
+    BEGIN
+        -- Check a vessel metadata
+        RETURN (
+            SELECT m.vessel_id
+                FROM auth.accounts a, auth.vessels v, api.metadata m
+                WHERE m.vessel_id = v.vessel_id
+                    AND auth.vessels.owner_email = auth.accounts.email
+                    AND auth.accounts.email = current_setting('user.email')
+            ) IS NOT NULL;
+    END;
+$has_vessel_metadata$ language plpgsql security definer;
+-- Description
+COMMENT ON FUNCTION
+    public.has_vessel_metadata_fn
+    IS 'Check if user has a vessel register';
 
 -- Or function?
 -- TODO Improve: return null until the vessel has sent metadata?
@@ -74,9 +105,10 @@ AS $vessel$
     BEGIN
         SELECT
             jsonb_build_object(
-                'name', v.name,
-                'mmsi', coalesce(v.mmsi, null),
-                'created_at', v.created_at::timestamp(0),
+                'name', coalesce(m.name, null),
+                'mmsi', coalesce(m.mmsi, null),
+                'created_at', v.created_at,
+                'first_contact', coalesce(m.created_at, null),
                 'last_contact', coalesce(m.time, null),
                 'geojson', coalesce(ST_AsGeoJSON(geojson_t.*)::json, null)
             )::jsonb || api.vessel_details_fn()::jsonb
@@ -95,7 +127,7 @@ AS $vessel$
                             latitude IS NOT NULL
                             AND longitude IS NOT NULL
                             AND vessel_id = current_setting('vessel.id', false)
-                        ORDER BY time DESC
+                        ORDER BY time DESC LIMIT 1
                 ) AS geojson_t
             WHERE
                 m.vessel_id = current_setting('vessel.id')
@@ -110,15 +142,16 @@ COMMENT ON FUNCTION
 
 -- Export user settings
 DROP FUNCTION IF EXISTS api.settings_fn;
-CREATE FUNCTION api.settings_fn(out settings json) RETURNS JSON
+CREATE OR REPLACE FUNCTION api.settings_fn(out settings json) RETURNS JSON
 AS $user_settings$
     BEGIN
        select row_to_json(row)::json INTO settings
         from (
-		    select email,first,last,preferences,created_at,
+            select a.email, a.first, a.last, a.preferences, a.created_at,
                 INITCAP(CONCAT (LEFT(first, 1), ' ', last)) AS username,
                 public.has_vessel_fn() as has_vessel
-            from auth.accounts
+                --public.has_vessel_metadata_fn() as has_vessel_metadata,
+            from auth.accounts a
             where email = current_setting('user.email')
                ) row;
     END;
@@ -142,7 +175,8 @@ AS $version$
         RETURN json_build_object('api_version', _appv,
                            'sys_version', _sysv,
                            'timescaledb', (SELECT extversion as timescaledb FROM pg_extension WHERE extname='timescaledb'),
-                           'postgis', (SELECT extversion as postgis FROM pg_extension WHERE extname='postgis'));
+                           'postgis', (SELECT extversion as postgis FROM pg_extension WHERE extname='postgis'),
+                           'postgrest', (SELECT rtrim(substring(application_name from 'PostgREST [0-9.]+')) as postgrest FROM pg_stat_activity WHERE application_name ilike '%postgrest%' LIMIT 1));
     END;
 $version$ language plpgsql security definer;
 -- Description
@@ -157,7 +191,8 @@ CREATE OR REPLACE VIEW api.versions_view AS
         --version() as sys_version
         rtrim(substring(version(), 0, 17)) AS sys_version,
         (SELECT extversion as timescaledb FROM pg_extension WHERE extname='timescaledb'),
-        (SELECT extversion as postgis FROM pg_extension WHERE extname='postgis')
+        (SELECT extversion as postgis FROM pg_extension WHERE extname='postgis'),
+        (SELECT rtrim(substring(application_name from 'PostgREST [0-9.]+')) as postgrest FROM pg_stat_activity WHERE application_name ilike '%postgrest%' limit 1)
     FROM app_settings
     WHERE name = 'app.version';
 -- Description
@@ -207,15 +242,17 @@ $vessel_details$
 DECLARE
 BEGIN
      RETURN ( WITH tbl AS (
-                SELECT mmsi,ship_type,length,beam,height FROM api.metadata WHERE vessel_id = current_setting('vessel.id', false)
+                SELECT mmsi,ship_type,length,beam,height,plugin_version,platform FROM api.metadata WHERE vessel_id = current_setting('vessel.id', false)
                 )
                 SELECT json_build_object(
-                        'ship_type', (SELECT ais.description FROM aistypes ais, tbl WHERE t.ship_type = ais.id),
-                        'country', (SELECT mid.country FROM mid, tbl WHERE LEFT(cast(mmsi as text), 3)::NUMERIC = mid.id),
-                        'alpha_2', (SELECT o.alpha_2 FROM mid m, iso3166 o, tbl WHERE LEFT(cast(mmsi as text), 3)::NUMERIC = m.id AND m.country_id = o.id),
-                        'length', t.ship_type,
+                        'ship_type', (SELECT ais.description FROM aistypes ais, tbl t WHERE t.ship_type = ais.id),
+                        'country', (SELECT mid.country FROM mid, tbl t WHERE LEFT(cast(t.mmsi as text), 3)::NUMERIC = mid.id),
+                        'alpha_2', (SELECT o.alpha_2 FROM mid m, iso3166 o, tbl t WHERE LEFT(cast(t.mmsi as text), 3)::NUMERIC = m.id AND m.country_id = o.id),
+                        'length', t.length,
                         'beam', t.beam,
-                        'height', t.height)
+                        'height', t.height,
+                        'plugin_version', t.plugin_version,
+                        'platform', t.platform)
                         FROM tbl t
             );
 END;
@@ -224,3 +261,96 @@ $vessel_details$ language plpgsql security definer;
 COMMENT ON FUNCTION
     api.vessel_details_fn
     IS 'Return vessel details such as metadata (length,beam,height), ais type and country name and country iso3166-alpha-2';
+
+DROP VIEW IF EXISTS api.eventlogs_view;
+CREATE VIEW api.eventlogs_view WITH (security_invoker=true,security_barrier=true) AS
+    SELECT pq.*
+        FROM public.process_queue pq
+        WHERE channel <> 'pre_logbook' AND (ref_id = current_setting('user.id', true)
+            OR ref_id = current_setting('vessel.id', true))
+        ORDER BY id ASC;
+-- Description
+COMMENT ON VIEW
+    api.eventlogs_view
+    IS 'Event logs view';
+
+DROP FUNCTION IF EXISTS api.update_logbook_observations_fn;
+-- Update/Add a specific user observations into logbook
+CREATE OR REPLACE FUNCTION api.update_logbook_observations_fn(IN _id INT, IN observations TEXT) RETURNS BOOLEAN AS
+$update_logbook_observations$
+DECLARE
+BEGIN
+    -- Merge existing observations with the new observations objects
+    RAISE NOTICE '-> update_logbook_extra_fn id:[%] observations:[%]', _id, observations;
+    -- { 'observations': { 'seaState': -1, 'cloudCoverage': -1, 'visibility': -1 } }
+    UPDATE api.logbook SET extra = public.jsonb_recursive_merge(extra, observations::jsonb) WHERE id = _id;
+    IF FOUND IS True THEN
+        RETURN True;
+    END IF;
+    RETURN False;
+END;
+$update_logbook_observations$ language plpgsql security definer;
+-- Description
+COMMENT ON FUNCTION
+    api.update_logbook_observations_fn
+    IS 'Update/Add logbook observations jsonb key pair value';
+
+CREATE TYPE public_type AS ENUM ('public_logs', 'public_logs_list', 'public_timelapse', 'public_monitoring', 'public_stats');
+CREATE or replace FUNCTION api.ispublic_fn(IN boat TEXT, IN _type TEXT, IN _id INTEGER DEFAULT NULL) RETURNS BOOLEAN AS $ispublic$
+DECLARE
+    vessel TEXT := '^' || boat || '$';
+    anonymous BOOLEAN := False;
+    valid_public_type BOOLEAN := False;
+    public_logs BOOLEAN := False;
+BEGIN
+    -- If boat is not NULL
+    IF boat IS NULL THEN
+        RAISE WARNING '-> ispublic_fn invalid input %', boat;
+        RETURN False;
+    END IF;
+    -- Check if public_type is valid enum
+    SELECT _type::name = any(enum_range(null::public_type)::name[]) INTO valid_public_type;
+    IF valid_public_type IS False THEN
+        -- Ignore entry if type is invalid
+        RAISE WARNING '-> ispublic_fn invalid input type %', _type;
+        RETURN False;
+    END IF;
+
+    RAISE WARNING '-> ispublic_fn _type [%], _id [%]', _type, _id;
+    IF _type ~ '^public_(logs|timelapse)$' AND _id > 0 THEN
+        WITH log as (
+            SELECT vessel_id from api.logbook l where l.id = _id
+        )
+        SELECT EXISTS (
+            SELECT l.vessel_id
+            FROM auth.accounts a, auth.vessels v, jsonb_each_text(a.preferences) as prefs, log l
+            WHERE v.vessel_id = l.vessel_id
+                    AND a.email = v.owner_email
+                    AND a.preferences->>'public_vessel'::text ~* vessel
+                    AND prefs.key = _type::TEXT
+                    AND prefs.value::BOOLEAN = true
+            ) into anonymous;
+        RAISE WARNING '-> ispublic_fn public_logs output boat:[%], type:[%], result:[%]', boat, _type, anonymous;
+	    IF anonymous IS True THEN
+	        RETURN True;
+	    END IF;
+    ELSE
+	    SELECT EXISTS (
+	        SELECT a.email
+	            FROM auth.accounts a, jsonb_each_text(a.preferences) as prefs
+	            WHERE a.preferences->>'public_vessel'::text ~* vessel
+	                    AND prefs.key = _type::TEXT
+	                    AND prefs.value::BOOLEAN = true
+	        ) into anonymous;
+	    RAISE WARNING '-> ispublic_fn output boat:[%], type:[%], result:[%]', boat, _type, anonymous;
+	    IF anonymous IS True THEN
+	        RETURN True;
+	    END IF;
+    END IF;
+    RETURN False;
+END
+$ispublic$ language plpgsql security definer;
+-- Description
+COMMENT ON FUNCTION
+    api.ispublic_fn
+    IS 'Is web page publicly accessible by register boat name and/or logbook id';

initdb/02_5_signalk_auth_otp.sql

@@ -12,8 +12,8 @@ DROP TABLE IF EXISTS auth.otp;
 CREATE TABLE IF NOT EXISTS auth.otp (
   -- update email type to CITEXT, https://www.postgresql.org/docs/current/citext.html
   user_email CITEXT NOT NULL PRIMARY KEY REFERENCES auth.accounts(email) ON DELETE RESTRICT,
-  otp_pass VARCHAR(10) NOT NULL,
-  otp_timestamp TIMESTAMP WITHOUT TIME ZONE DEFAULT NOW(),
+  otp_pass TEXT NOT NULL,
+  otp_timestamp TIMESTAMPTZ DEFAULT NOW(),
   otp_tries SMALLINT NOT NULL DEFAULT '0'
 );
 -- Description
@@ -22,7 +22,8 @@ COMMENT ON TABLE
     IS 'Stores temporal otp code for up to 15 minutes';
 -- Indexes
 CREATE INDEX otp_pass_idx ON auth.otp (otp_pass);
-CREATE INDEX otp_user_email_idx ON auth.otp (user_email);
+-- Duplicate Indexes
+--CREATE INDEX otp_user_email_idx ON auth.otp (user_email);
 
 DROP FUNCTION IF EXISTS public.generate_uid_fn;
 CREATE OR REPLACE FUNCTION public.generate_uid_fn(size INT) RETURNS TEXT
@@ -99,6 +100,8 @@ AS $recover_fn$
         -- Generate OTP
         otp_pass := api.generate_otp_fn(email);
         SELECT CONCAT('uuid=', _user_id, '&token=', otp_pass) INTO _reset_qs;
+        -- Enable email_notifications
+        PERFORM api.update_user_preferences_fn('{email_notifications}'::TEXT, True::TEXT);
         -- Send email/notifications
         user_settings := '{"email": "' || _email || '", "reset_qs": "' || _reset_qs || '"}';
         PERFORM send_notification_fn('email_reset'::TEXT, user_settings::JSONB);
@@ -115,6 +118,7 @@ CREATE OR REPLACE FUNCTION api.reset(in pass text, in token text, in uuid text)
 AS $reset_fn$
     DECLARE
         _email TEXT := NULL;
+        _pass TEXT := pass;
     BEGIN
          -- Check parameters
         IF token IS NULL OR uuid IS NULL OR pass IS NULL THEN
@@ -129,7 +133,7 @@ AS $reset_fn$
             END IF;
             -- Set user new password
             UPDATE auth.accounts
-                SET pass = pass
+                SET pass = _pass
                 WHERE email = _email;
             -- Enable email_validation into user preferences
             PERFORM api.update_user_preferences_fn('{email_valid}'::TEXT, True::TEXT);

initdb/02_6_signalk_roles.sql

@@ -15,13 +15,13 @@ select current_database();
 --
 -- api_anonymous
 -- nologin
--- api_anonymous role in the database with which to execute anonymous web requests, limit 10 connections
+-- api_anonymous role in the database with which to execute anonymous web requests, limit 20 connections
 -- api_anonymous allows JWT token generation with an expiration time via function api.login() from auth.accounts table
-create role api_anonymous WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOLOGIN NOBYPASSRLS NOREPLICATION CONNECTION LIMIT 10;
+create role api_anonymous WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOLOGIN NOBYPASSRLS NOREPLICATION CONNECTION LIMIT 20;
 comment on role api_anonymous is
     'The role that PostgREST will switch to when a user is not authenticated.';
--- Limit to 10 connections
---alter user api_anonymous connection limit 10;
+-- Limit to 20 connections
+--alter user api_anonymous connection limit 20;
 grant usage on schema api to api_anonymous;
 -- explicitly limit EXECUTE privileges to only signup and login and reset functions
 grant execute on function api.login(text,text) to api_anonymous;
@@ -38,6 +38,20 @@ grant execute on function api.pushover_fn(text,text) to api_anonymous;
 grant execute on function api.telegram_fn(text,text) to api_anonymous;
 grant execute on function api.telegram_otp_fn(text) to api_anonymous;
 --grant execute on function api.generate_otp_fn(text) to api_anonymous;
+grant execute on function api.ispublic_fn(text,text,integer) to api_anonymous;
+grant execute on function api.timelapse_fn to api_anonymous;
+grant execute on function api.stats_logs_fn to api_anonymous;
+grant execute on function api.stats_stays_fn to api_anonymous;
+grant execute on function api.status_fn to api_anonymous;
+-- Allow read on TABLES on API schema
+--GRANT SELECT ON TABLE api.metrics,api.logbook,api.moorages,api.stays,api.metadata,api.stays_at TO api_anonymous;
+-- Allow read on VIEWS on API schema
+--GRANT SELECT ON TABLE api.logs_view,api.moorages_view,api.stays_view TO api_anonymous;
+--GRANT SELECT ON TABLE api.log_view,api.moorage_view,api.stay_view,api.vessels_view TO api_anonymous;
+GRANT SELECT ON ALL TABLES IN SCHEMA api TO api_anonymous;
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO api_anonymous;
+--grant execute on function public.st_asgeojson(record,text,integer,boolean) to api_anonymous;
+--grant execute on function public.st_makepoint(float,float) to api_anonymous;
 
 -- authenticator
 -- login role
@@ -46,25 +60,28 @@ comment on role authenticator is
     'Role that serves as an entry-point for API servers such as PostgREST.';
 grant api_anonymous to authenticator;
 
--- Grafana user and role with login, read-only, limit 15 connections
-CREATE ROLE grafana WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS NOREPLICATION CONNECTION LIMIT 15 LOGIN PASSWORD 'mysecretpassword';
+-- Grafana user and role with login, read-only, limit 20 connections
+CREATE ROLE grafana WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS NOREPLICATION CONNECTION LIMIT 20 LOGIN PASSWORD 'mysecretpassword';
 comment on role grafana is
     'Role that grafana will use for authenticated web users.';
 -- Allow API schema and Tables
 GRANT USAGE ON SCHEMA api TO grafana;
+-- Allow read on SEQUENCE on API schema
 GRANT USAGE, SELECT ON SEQUENCE api.logbook_id_seq,api.metadata_id_seq,api.moorages_id_seq,api.stays_id_seq TO grafana;
-GRANT SELECT ON TABLE api.metrics,api.logbook,api.moorages,api.stays,api.metadata TO grafana;
+-- Allow read on TABLES on API schema
+GRANT SELECT ON TABLE api.metrics,api.logbook,api.moorages,api.stays,api.metadata,api.stays_at TO grafana;
 -- Allow read on VIEWS on API schema
 GRANT SELECT ON TABLE api.logs_view,api.moorages_view,api.stays_view TO grafana;
 GRANT SELECT ON TABLE api.log_view,api.moorage_view,api.stay_view,api.vessels_view TO grafana;
-GRANT SELECT ON TABLE api.metrics,api.logbook,api.moorages,api.stays,api.metadata,api.stays_at TO grafana;
+GRANT SELECT ON TABLE api.monitoring_view,api.monitoring_view2,api.monitoring_view3 TO grafana;
+GRANT SELECT ON TABLE api.monitoring_humidity,api.monitoring_voltage,api.monitoring_temperatures TO grafana;
 -- Allow Auth schema and Tables
 GRANT USAGE ON SCHEMA auth TO grafana;
 GRANT SELECT ON TABLE auth.vessels TO grafana;
 GRANT EXECUTE ON FUNCTION public.citext_eq(citext, citext) TO grafana;
 
--- Grafana_auth authenticator user and role with login, read-only on auth.accounts, limit 15 connections
-CREATE ROLE grafana_auth WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS NOREPLICATION CONNECTION LIMIT 15 LOGIN PASSWORD 'mysecretpassword';
+-- Grafana_auth authenticator user and role with login, read-only on auth.accounts, limit 20 connections
+CREATE ROLE grafana_auth WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS NOREPLICATION CONNECTION LIMIT 20 LOGIN PASSWORD 'mysecretpassword';
 comment on role grafana_auth is
     'Role that grafana auth proxy authenticator via apache.';
 -- Allow read on VIEWS on API schema
@@ -76,63 +93,45 @@ GRANT SELECT ON TABLE auth.accounts TO grafana_auth;
 GRANT SELECT ON TABLE auth.vessels TO grafana_auth;
 -- GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO grafana_auth;
 GRANT EXECUTE ON FUNCTION public.citext_eq(citext, citext) TO grafana_auth;
+GRANT ALL ON SCHEMA public TO grafana_auth; -- Important if grafana database in pg
 
 -- User:
 -- nologin, web api only
--- read-only for all and Read-Write on logbook, stays and moorage except for specific (name, notes) COLUMNS
+-- read-only for all and Read on logbook, stays and moorage and Write only for specific (name, notes) COLUMNS
 CREATE ROLE user_role WITH NOLOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS NOREPLICATION;
 comment on role user_role is
     'Role that PostgREST will switch to for authenticated web users.';
 GRANT user_role to authenticator;
 GRANT USAGE ON SCHEMA api TO user_role;
+-- Allow read on SEQUENCE on API schema
 GRANT USAGE, SELECT ON SEQUENCE api.logbook_id_seq,api.metadata_id_seq,api.moorages_id_seq,api.stays_id_seq TO user_role;
+-- Allow read on TABLES on API schema
 GRANT SELECT ON TABLE api.metrics,api.logbook,api.moorages,api.stays,api.metadata,api.stays_at TO user_role;
+GRANT SELECT ON TABLE public.process_queue TO user_role;
 -- To check?
 GRANT SELECT ON TABLE auth.vessels TO user_role;
--- Allow users to update certain columns
-GRANT UPDATE (name, notes) ON api.logbook TO user_role;
-GRANT UPDATE (name, notes, stay_code) ON api.stays TO user_role;
+-- Allow users to update certain columns on specific TABLES on API schema
+GRANT UPDATE (name, _from, _to, notes) ON api.logbook TO user_role;
+GRANT UPDATE (name, notes, stay_code, active, departed) ON api.stays TO user_role;
 GRANT UPDATE (name, notes, stay_code, home_flag) ON api.moorages TO user_role;
+-- Allow users to remove logs and stays
+GRANT DELETE ON api.logbook,api.stays,api.moorages TO user_role;
+-- Allow EXECUTE on all FUNCTIONS on API and public schema
 GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA api TO user_role;
--- explicitly limit EXECUTE privileges to pgrest db-pre-request function
---GRANT EXECUTE ON FUNCTION public.check_jwt() TO user_role;
--- Allow others functions or allow all in public !! ??
---GRANT EXECUTE ON FUNCTION api.export_logbook_geojson_linestring_fn(int4) TO user_role;
---GRANT EXECUTE ON FUNCTION public.st_asgeojson(text) TO user_role;
---GRANT EXECUTE ON FUNCTION public.geography_eq(geography, geography) TO user_role;
--- TODO should not be need !! ??
 GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO user_role;
 
 -- pg15 feature security_invoker=true,security_barrier=true
 GRANT SELECT ON TABLE api.logs_view,api.moorages_view,api.stays_view TO user_role;
 GRANT SELECT ON TABLE api.log_view,api.moorage_view,api.stay_view,api.vessels_view TO user_role;
-GRANT SELECT ON TABLE api.monitoring_view TO user_role;
+GRANT SELECT ON TABLE api.monitoring_view,api.monitoring_view2,api.monitoring_view3,api.explore_view TO user_role;
+GRANT SELECT ON TABLE api.monitoring_humidity,api.monitoring_voltage,api.monitoring_temperatures TO user_role;
+GRANT SELECT ON TABLE api.stats_moorages_away_view,api.versions_view TO user_role;
 GRANT SELECT ON TABLE api.total_info_view TO user_role;
 GRANT SELECT ON TABLE api.stats_logs_view TO user_role;
 GRANT SELECT ON TABLE api.stats_moorages_view TO user_role;
--- Update ownership for security user_role as run by web user.
--- Web listing
---ALTER VIEW api.stays_view OWNER TO user_role;
---ALTER VIEW api.moorages_view OWNER TO user_role;
---ALTER VIEW api.logs_view OWNER TO user_role;
---ALTER VIEW api.vessel_p_view OWNER TO user_role;
---ALTER VIEW api.monitoring_view OWNER TO user_role;
--- Remove all permissions except select
---REVOKE UPDATE, TRUNCATE, REFERENCES, DELETE, TRIGGER, INSERT ON TABLE api.stays_view FROM user_role;
---REVOKE UPDATE, TRUNCATE, REFERENCES, DELETE, TRIGGER, INSERT ON TABLE api.moorages_view FROM user_role;
---REVOKE UPDATE, TRUNCATE, REFERENCES, DELETE, TRIGGER, INSERT ON TABLE api.logs_view FROM user_role;
---REVOKE UPDATE, TRUNCATE, REFERENCES, DELETE, TRIGGER, INSERT ON TABLE api.monitoring_view FROM user_role;
-
--- Allow read and update on VIEWS
--- Web detail view
---ALTER VIEW api.log_view OWNER TO user_role;
--- Remove all permissions except select and update
---REVOKE TRUNCATE, DELETE, TRIGGER, INSERT ON TABLE api.log_view FROM user_role;
-
-ALTER VIEW api.vessels_view OWNER TO user_role;
--- Remove all permissions except select and update
-REVOKE TRUNCATE, DELETE, TRIGGER, INSERT ON TABLE api.vessels_view FROM user_role;
-
+GRANT SELECT ON TABLE api.eventlogs_view TO user_role;
+GRANT SELECT ON TABLE api.vessels_view TO user_role;
+GRANT SELECT ON TABLE api.moorages_stays_view TO user_role;
 
 -- Vessel:
 -- nologin
@@ -142,8 +141,10 @@ comment on role vessel_role is
     'Role that PostgREST will switch to for authenticated web vessels.';
 GRANT vessel_role to authenticator;
 GRANT USAGE ON SCHEMA api TO vessel_role;
-GRANT INSERT, UPDATE, SELECT ON TABLE api.metrics,api.logbook,api.moorages,api.stays,api.metadata TO vessel_role;
+-- Allow read on SEQUENCE on API schema
 GRANT USAGE, SELECT ON SEQUENCE api.logbook_id_seq,api.metadata_id_seq,api.moorages_id_seq,api.stays_id_seq TO vessel_role;
+-- Allow read/write on TABLES on API schema
+GRANT INSERT, UPDATE, SELECT ON TABLE api.metrics,api.logbook,api.moorages,api.stays,api.metadata TO vessel_role;
 GRANT INSERT ON TABLE public.process_queue TO vessel_role;
 GRANT USAGE, SELECT ON SEQUENCE public.process_queue_id_seq TO vessel_role;
 -- explicitly limit EXECUTE privileges to pgrest db-pre-request function
@@ -153,7 +154,11 @@ GRANT EXECUTE ON FUNCTION public.trip_in_progress_fn(text) to vessel_role;
 GRANT EXECUTE ON FUNCTION public.stay_in_progress_fn(text) to vessel_role;
 -- hypertable get_partition_hash ?!?
 GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA _timescaledb_internal TO vessel_role;
-
+-- on metrics st_makepoint
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO vessel_role;
+-- Oauth registration
+GRANT EXECUTE ON FUNCTION api.oauth() TO vessel_role;
+GRANT EXECUTE ON FUNCTION api.oauth_vessel(text,text) TO vessel_role;
 
 --- Scheduler:
 -- TODO: currently cron function are run as super user, switch to scheduler role.
@@ -225,6 +230,10 @@ CREATE POLICY api_scheduler_role ON api.metrics TO scheduler
 CREATE POLICY grafana_role ON api.metrics TO grafana
     USING (vessel_id = current_setting('vessel.id', false))
     WITH CHECK (false);
+-- Allow anonymous to select based on the vessel.id
+CREATE POLICY api_anonymous_role ON api.metrics TO api_anonymous
+    USING (vessel_id = current_setting('vessel.id', false))
+    WITH CHECK (false);
 
 -- Be sure to enable row level security on the table
 ALTER TABLE api.logbook ENABLE ROW LEVEL SECURITY;
@@ -249,6 +258,10 @@ CREATE POLICY api_scheduler_role ON api.logbook TO scheduler
 CREATE POLICY grafana_role ON api.logbook TO grafana
     USING (vessel_id = current_setting('vessel.id', false))
     WITH CHECK (false);
+-- Allow anonymous to select based on the vessel.id
+CREATE POLICY api_anonymous_role ON api.logbook TO api_anonymous
+    USING (vessel_id = current_setting('vessel.id', false))
+    WITH CHECK (false);
 
 -- Be sure to enable row level security on the table
 ALTER TABLE api.stays ENABLE ROW LEVEL SECURITY;
@@ -272,6 +285,10 @@ CREATE POLICY api_scheduler_role ON api.stays TO scheduler
 CREATE POLICY grafana_role ON api.stays TO grafana
     USING (vessel_id = current_setting('vessel.id', false))
     WITH CHECK (false);
+-- Allow anonymous to select based on the vessel.id
+CREATE POLICY api_anonymous_role ON api.stays TO api_anonymous
+    USING (vessel_id = current_setting('vessel.id', false))
+    WITH CHECK (false);
 
 -- Be sure to enable row level security on the table
 ALTER TABLE api.moorages ENABLE ROW LEVEL SECURITY;
@@ -295,6 +312,10 @@ CREATE POLICY api_scheduler_role ON api.moorages TO scheduler
 CREATE POLICY grafana_role ON api.moorages TO grafana
     USING (vessel_id = current_setting('vessel.id', false))
     WITH CHECK (false);
+-- Allow anonymous to select based on the vessel.id
+CREATE POLICY api_anonymous_role ON api.moorages TO api_anonymous
+    USING (vessel_id = current_setting('vessel.id', false))
+    WITH CHECK (false);
 
 -- Be sure to enable row level security on the table
 ALTER TABLE auth.vessels ENABLE ROW LEVEL SECURITY;
@@ -329,7 +350,30 @@ CREATE POLICY admin_all ON auth.accounts TO current_user
 CREATE POLICY api_user_role ON auth.accounts TO user_role
     USING (email = current_setting('user.email', true))
     WITH CHECK (email = current_setting('user.email', true));
+-- Allow scheduler see all rows and add any rows
+CREATE POLICY api_scheduler_role ON auth.accounts TO scheduler
+    USING (email = current_setting('user.email', true))
+    WITH CHECK (email = current_setting('user.email', true));
 -- Allow grafana_auth to select
 CREATE POLICY grafana_proxy_role ON auth.accounts TO grafana_auth
     USING (true)
     WITH CHECK (false);
+
+-- Be sure to enable row level security on the table
+ALTER TABLE public.process_queue ENABLE ROW LEVEL SECURITY;
+-- Administrator can see all rows and add any rows
+CREATE POLICY admin_all ON public.process_queue TO current_user
+    USING (true)
+    WITH CHECK (true);
+-- Allow vessel_role to insert and select on their own records
+CREATE POLICY api_vessel_role ON public.process_queue TO vessel_role
+    USING (ref_id = current_setting('user.id', true) OR ref_id = current_setting('vessel.id', true))
+    WITH CHECK (true);
+-- Allow user_role to update and select on their own records
+CREATE POLICY api_user_role ON public.process_queue TO user_role
+    USING (ref_id = current_setting('user.id', true) OR ref_id = current_setting('vessel.id', true))
+    WITH CHECK (ref_id = current_setting('user.id', true) OR ref_id = current_setting('vessel.id', true));
+-- Allow scheduler see all rows and updates any rows
+CREATE POLICY api_scheduler_role ON public.process_queue TO scheduler
+    USING (true)
+    WITH CHECK (false);

initdb/04pgcron.sql

@@ -10,20 +10,24 @@ CREATE EXTENSION IF NOT EXISTS pg_cron; -- provides a simple cron-based job sche
 -- TRUNCATE table jobs
 --TRUNCATE TABLE cron.job CONTINUE IDENTITY RESTRICT;
 
--- Create a every 5 minutes or minute job cron_process_new_logbook_fn ??
-SELECT cron.schedule('cron_new_logbook', '*/5 * * * *', 'select public.cron_process_new_logbook_fn()');
+-- Create a every 5 minutes or minute job cron_process_pre_logbook_fn ??
+SELECT cron.schedule('cron_pre_logbook', '*/5 * * * *', 'select public.cron_process_pre_logbook_fn()');
+--UPDATE cron.job SET database = 'signalk' where jobname = 'cron_pre_logbook';
+
+-- Create a every 6 minutes or minute job cron_process_new_logbook_fn ??
+SELECT cron.schedule('cron_new_logbook', '*/6 * * * *', 'select public.cron_process_new_logbook_fn()');
 --UPDATE cron.job SET database = 'signalk' where jobname = 'cron_new_logbook';
 
--- Create a every 5 minute job cron_process_new_stay_fn
-SELECT cron.schedule('cron_new_stay', '*/6 * * * *', 'select public.cron_process_new_stay_fn()');
+-- Create a every 7 minute job cron_process_new_stay_fn
+SELECT cron.schedule('cron_new_stay', '*/7 * * * *', 'select public.cron_process_new_stay_fn()');
 --UPDATE cron.job SET database = 'signalk' where jobname = 'cron_new_stay';
 
 -- Create a every 6 minute job cron_process_new_moorage_fn, delay from stay to give time to generate geo reverse location, eg: name
-SELECT cron.schedule('cron_new_moorage', '*/7 * * * *', 'select public.cron_process_new_moorage_fn()');
+--SELECT cron.schedule('cron_new_moorage', '*/7 * * * *', 'select public.cron_process_new_moorage_fn()');
 --UPDATE cron.job SET database = 'signalk' where jobname = 'cron_new_moorage';
 
--- Create a every 10 minute job cron_process_monitor_offline_fn
-SELECT cron.schedule('cron_monitor_offline', '*/10 * * * *', 'select public.cron_process_monitor_offline_fn()');
+-- Create a every 11 minute job cron_process_monitor_offline_fn
+SELECT cron.schedule('cron_monitor_offline', '*/11 * * * *', 'select public.cron_process_monitor_offline_fn()');
 --UPDATE cron.job SET database = 'signalk' where jobname = 'cron_monitor_offline';
 
 -- Create a every 10 minute job cron_process_monitor_online_fn
@@ -42,27 +46,51 @@ SELECT cron.schedule('cron_monitor_online', '*/10 * * * *', 'select public.cron_
 --SELECT cron.schedule('cron_new_account_otp', '*/6 * * * *', 'select public.cron_process_new_account_otp_validation_fn()');
 --UPDATE cron.job SET database = 'signalk' where jobname = 'cron_new_account_otp';
 
+-- Create a every 5 minute job cron_process_grafana_fn
+SELECT cron.schedule('cron_grafana', '*/5 * * * *', 'select public.cron_process_grafana_fn()');
+
+-- Create a every 5 minute job cron_process_windy_fn
+SELECT cron.schedule('cron_windy', '*/5 * * * *', 'select public.cron_windy_fn()');
+
 -- Notification
 -- Create a every 1 minute job cron_process_new_notification_queue_fn, new_account, new_vessel, _new_account_otp
-SELECT cron.schedule('cron_new_notification', '*/2 * * * *', 'select public.cron_process_new_notification_fn()');
+SELECT cron.schedule('cron_new_notification', '*/1 * * * *', 'select public.cron_process_new_notification_fn()');
 --UPDATE cron.job SET database = 'signalk' where jobname = 'cron_new_notification';
 
 -- Maintenance
--- Vacuum database at “At 01:01 on Sunday.”
-SELECT cron.schedule('cron_vacuum', '1 1 * * 0', 'VACUUM (FULL, VERBOSE, ANALYZE, INDEX_CLEANUP) api.logbook,api.stays,api.moorages,api.metadata,api.metrics;');
--- Remove all jobs log at “At 02:02 on Sunday.”
+-- Vacuum database schema api at "At 01:31 on Sunday."
+SELECT cron.schedule('cron_vacuum_api', '31 1 * * 0', 'VACUUM (FULL, VERBOSE, ANALYZE, INDEX_CLEANUP) api.logbook,api.stays,api.moorages,api.metadata,api.metrics;');
+-- Vacuum database schema auth at "At 01:01 on Sunday."
+SELECT cron.schedule('cron_vacuum_auth', '1 1 * * 0', 'VACUUM (FULL, VERBOSE, ANALYZE, INDEX_CLEANUP) auth.accounts,auth.vessels,auth.otp;');
+-- Remove old jobs log at "At 02:02 on Sunday."
 SELECT cron.schedule('job_run_details_cleanup', '2 2 * * 0', 'select public.job_run_details_cleanup_fn()');
+-- Rebuilding indexes schema api at "first day of each month at 23:15."
+SELECT cron.schedule('cron_reindex_api', '15 23 1 * *', 'REINDEX TABLE CONCURRENTLY api.logbook; REINDEX TABLE CONCURRENTLY api.stays; REINDEX TABLE CONCURRENTLY api.moorages; REINDEX TABLE CONCURRENTLY api.metadata;');
+-- Rebuilding indexes schema auth at "first day of each month at 23:01."
+SELECT cron.schedule('cron_reindex_auth', '1 23 1 * *', 'REINDEX TABLE CONCURRENTLY auth.accounts; REINDEX TABLE CONCURRENTLY auth.vessels; REINDEX TABLE CONCURRENTLY auth.otp;');
 -- Any other maintenance require?
 
 -- OTP
--- Create a every 15 minute job cron_process_prune_otp_fn
-SELECT cron.schedule('cron_prune_otp', '*/15 * * * *', 'select public.cron_process_prune_otp_fn()');
+-- Create a every 15 minute job cron_prune_otp_fn
+SELECT cron.schedule('cron_prune_otp', '*/15 * * * *', 'select public.cron_prune_otp_fn()');
+
+-- Alerts
+-- Create a every 11 minute job cron_alerts_fn
+SELECT cron.schedule('cron_alerts', '*/11 * * * *', 'select public.cron_alerts_fn()');
+
+-- Notifications/Reminders of no vessel & no metadata & no activity
+-- At 08:05 on Sunday.
+-- At 08:05 on every 4th day-of-month if it's on Sunday.
+SELECT cron.schedule('cron_no_vessel', '5 8 */4 * 0', 'select public.cron_no_vessel_fn()');
+SELECT cron.schedule('cron_no_metadata', '5 8 */4 * 0', 'select public.cron_no_metadata_fn()');
+SELECT cron.schedule('cron_no_activity', '5 8 */4 * 0', 'select public.cron_no_activity_fn()');
 
 -- Cron job settings
 UPDATE cron.job SET database = 'signalk';
-UPDATE cron.job SET username = 'username'; -- TODO update to scheduler, pending process_queue update
---UPDATE cron.job SET username = 'username' where jobname = 'cron_vacuum'; -- TODO Update to superuser for vaccuum permissions
+UPDATE cron.job SET username = current_user; -- TODO update to scheduler, pending process_queue update
+--UPDATE cron.job SET username = 'username' where jobname = 'cron_vacuum'; -- TODO Update to superuser for vacuum permissions
 UPDATE cron.job SET nodename = '/var/run/postgresql/'; -- VS default localhost ??
+UPDATE cron.job	SET database = 'postgres' WHERE jobname = 'job_run_details_cleanup';
 -- check job lists
 SELECT * FROM cron.job;
 -- unschedule by job id
@@ -72,6 +100,6 @@ SELECT * FROM cron.job;
 -- TRUNCATE TABLE cron.job_run_details
 --TRUNCATE TABLE cron.job_run_details CONTINUE IDENTITY RESTRICT;
 -- check job log
-select * from cron.job_run_details ORDER BY end_time DESC LIMIT 10;
+SELECT * FROM cron.job_run_details ORDER BY end_time DESC;
 -- DEBUG Disable all
 UPDATE cron.job SET active = False;

initdb/07naturalearthdata.sql

@@ -18,7 +18,7 @@ select current_database();
 \c signalk
 
 CREATE TABLE public.ne_10m_geography_marine_polys (
-	gid serial4 NOT NULL,
+	gid INT GENERATED ALWAYS AS IDENTITY NOT NULL,
 	featurecla TEXT NULL,
 	"name" TEXT NULL,
 	namealt TEXT NULL,

initdb/99_migrations_202401.sql

@@ -0,0 +1,457 @@
+---------------------------------------------------------------------------
+-- Copyright 2021-2024 Francois Lacroix <xbgmsharp@gmail.com>
+-- This file is part of PostgSail which is released under Apache License, Version 2.0 (the "License").
+-- See file LICENSE or go to http://www.apache.org/licenses/LICENSE-2.0 for full license details.
+--
+-- Migration January 2024
+--
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+\echo 'Force timezone, just in case'
+set timezone to 'UTC';
+
+COMMENT ON FUNCTION
+    public.cron_process_new_moorage_fn
+    IS 'Deprecated, init by pg_cron to check for new moorage pending update, if so perform process_moorage_queue_fn';
+
+DROP FUNCTION IF EXISTS reverse_geoip_py_fn;
+CREATE OR REPLACE FUNCTION reverse_geoip_py_fn(IN _ip TEXT) RETURNS JSONB
+AS $reverse_geoip_py$
+    """
+    Return ipapi.co ip details
+    """
+    import requests
+    import json
+
+    # requests
+    url = f'https://ipapi.co/{_ip}/json/'
+    r = requests.get(url)
+    #print(r.text)
+    #plpy.notice('IP [{}] [{}]'.format(_ip, r.status_code))
+    if r.status_code == 200:
+        #plpy.notice('Got [{}] [{}]'.format(r.text, r.status_code))
+        return r.json()
+    else:
+        plpy.error('Failed to get ip details')
+    return {}
+$reverse_geoip_py$ IMMUTABLE strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.reverse_geoip_py_fn
+    IS 'Retrieve reverse geo IP location via ipapi.co using plpython3u';
+
+DROP FUNCTION IF EXISTS overpass_py_fn;
+CREATE OR REPLACE FUNCTION overpass_py_fn(IN lon NUMERIC, IN lat NUMERIC,
+    OUT geo JSONB) RETURNS JSONB
+AS $overpass_py$
+    """
+    Return https://overpass-turbo.eu seamark details within 400m
+    https://overpass-turbo.eu/s/1EaG
+    https://wiki.openstreetmap.org/wiki/Key:seamark:type
+    """
+    import requests
+    import json
+    import urllib.parse
+
+    headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com'}
+    payload = """
+    [out:json][timeout:20];
+    is_in({0},{1})->.result_areas;
+    (
+      area.result_areas["seamark:type"~"(mooring|harbour)"][~"^seamark:.*:category$"~"."];
+      area.result_areas["leisure"="marina"][~"name"~"."];
+    );
+    out tags;
+    nwr(around:400.0,{0},{1})->.all;
+    (
+        nwr.all["seamark:type"~"(mooring|harbour)"][~"^seamark:.*:category$"~"."];
+        nwr.all["seamark:type"~"(anchorage|anchor_berth|berth)"];
+        nwr.all["leisure"="marina"];
+        nwr.all["natural"~"(bay|beach)"];
+    );
+    out tags;
+    """.format(lat, lon)
+    data = urllib.parse.quote(payload, safe="");
+    url = f'https://overpass-api.de/api/interpreter?data={data}'.format(data)
+    r = requests.get(url, headers)
+    #print(r.text)
+    #plpy.notice(url)
+    plpy.notice('overpass-api coord lon[{}] lat[{}] [{}]'.format(lon, lat, r.status_code))
+    if r.status_code == 200 and "elements" in r.json():
+        r_dict = r.json()
+        plpy.notice('overpass-api Got [{}]'.format(r_dict["elements"]))
+        if r_dict["elements"]:
+            if "tags" in r_dict["elements"][0] and r_dict["elements"][0]["tags"]:
+                return r_dict["elements"][0]["tags"]; # return the first element
+        return {}
+    else:
+        plpy.notice('overpass-api Failed to get overpass-api details')
+    return {}
+$overpass_py$ IMMUTABLE strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.overpass_py_fn
+    IS 'Return https://overpass-turbo.eu seamark details within 400m using plpython3u';
+
+CREATE OR REPLACE FUNCTION get_app_settings_fn(OUT app_settings jsonb)
+    RETURNS jsonb
+    AS $get_app_settings$
+DECLARE
+BEGIN
+    SELECT
+        jsonb_object_agg(name, value) INTO app_settings
+    FROM
+        public.app_settings
+    WHERE
+        name LIKE 'app.email%'
+        OR name LIKE 'app.pushover%'
+        OR name LIKE 'app.url'
+        OR name LIKE 'app.telegram%'
+        OR name LIKE 'app.grafana_admin_uri'
+        OR name LIKE 'app.keycloak_uri';
+END;
+$get_app_settings$
+LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION keycloak_auth_py_fn(IN _v_id TEXT,
+    IN _user JSONB, IN app JSONB) RETURNS JSONB
+AS $keycloak_auth_py$
+    """
+    Addkeycloak user
+    """
+    import requests
+    import json
+    import urllib.parse
+
+    safe_uri = host = user = pwd = None
+    if 'app.keycloak_uri' in app and app['app.keycloak_uri']:
+        #safe_uri = urllib.parse.quote(app['app.keycloak_uri'], safe=':/?&=')
+        _ = urllib.parse.urlparse(app['app.keycloak_uri'])
+        host = _.netloc.split('@')[-1]
+        user = _.netloc.split(':')[0]
+        pwd = _.netloc.split(':')[1].split('@')[0]
+    else:
+        plpy.error('Error no keycloak_uri defined, check app settings')
+        return none
+
+    if not host or not user or not pwd:
+        plpy.error('Error parsing keycloak_uri, check app settings')
+        return None
+
+    if not 'email' in _user and _user['email']:
+        plpy.error('Error parsing user email, check user settings')
+        return none
+
+    if not _v_id:
+        plpy.error('Error parsing vessel_id')
+        return none
+
+    _headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com'}
+    _payload = {'client_id':'admin-cli','grant_type':'password','username':user,'password':pwd}
+    url = f'{_.scheme}://{host}/realms/master/protocol/openid-connect/token'.format(_.scheme, host)
+    r = requests.post(url, headers=_headers, data=_payload, timeout=(5, 60))
+    #print(r.text)
+    #plpy.notice(url)
+    if r.status_code == 200 and 'access_token' in r.json():
+        response = r.json()
+        plpy.notice(response)
+        _headers['Authorization'] = 'Bearer '+ response['access_token']
+        _headers['Content-Type'] = 'application/json'
+        url = f'{_.scheme}://{host}/admin/realms/postgsail/users'.format(_.scheme, host)
+        _payload = {
+            "enabled": "true",
+            "email": _user['email'],
+            "firstName": _user['recipient'],
+            "attributes": {"vessel_id": _v_id},
+            "emailVerified": True,
+            "requiredActions":["UPDATE_PROFILE", "UPDATE_PASSWORD"]
+        }
+        plpy.notice(_payload)
+        data = json.dumps(_payload)
+        r = requests.post(url, headers=_headers, data=data, timeout=(5, 60))
+        if r.status_code != 201:
+            #print("Error creating user: {status}".format(status=r.status_code))
+            plpy.error(f'Error creating user: {user} {status}'.format(user=_payload['email'], status=r.status_code))
+            return None
+        else:
+            #print("Created user : {u}]".format(u=_payload['email']))
+            plpy.notice('Created user : {u} {t}, {l}'.format(u=_payload['email'], t=r.text, l=r.headers['location']))
+            user_url = "{user_url}/execute-actions-email".format(user_url=r.headers['location'])
+            _payload = ["UPDATE_PASSWORD"]
+            plpy.notice(_payload)
+            data = json.dumps(_payload)
+            r = requests.put(user_url, headers=_headers, data=data, timeout=(5, 60))
+            if r.status_code != 204:
+              plpy.error('Error execute-actions-email: {u} {s}'.format(u=_user['email'], s=r.status_code))
+            else:
+              plpy.notice('execute-actions-email: {u} {s}'.format(u=_user['email'], s=r.status_code))
+            return None
+    else:
+        plpy.error(f'Error getting admin access_token: {status}'.format(status=r.status_code))
+    return None
+$keycloak_auth_py$ strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.keycloak_auth_py_fn
+    IS 'Return set oauth user attribute into keycloak using plpython3u';
+
+CREATE OR REPLACE FUNCTION keycloak_py_fn(IN user_id TEXT, IN vessel_id TEXT,
+    IN app JSONB) RETURNS JSONB
+AS $keycloak_py$
+    """
+    Add vessel_id user attribute to keycloak user {user_id}
+    """
+    import requests
+    import json
+    import urllib.parse
+
+    safe_uri = host = user = pwd = None
+    if 'app.keycloak_uri' in app and app['app.keycloak_uri']:
+        #safe_uri = urllib.parse.quote(app['app.keycloak_uri'], safe=':/?&=')
+        _ = urllib.parse.urlparse(app['app.keycloak_uri'])
+        host = _.netloc.split('@')[-1]
+        user = _.netloc.split(':')[0]
+        pwd = _.netloc.split(':')[1].split('@')[0]
+    else:
+        plpy.error('Error no keycloak_uri defined, check app settings')
+        return None
+
+    if not host or not user or not pwd:
+        plpy.error('Error parsing keycloak_uri, check app settings')
+        return None
+
+    _headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com'}
+    _payload = {'client_id':'admin-cli','grant_type':'password','username':user,'password':pwd}
+    url = f'{_.scheme}://{host}/realms/master/protocol/openid-connect/token'.format(_.scheme, host)
+    r = requests.post(url, headers=_headers, data=_payload, timeout=(5, 60))
+    #print(r.text)
+    #plpy.notice(url)
+    if r.status_code == 200 and 'access_token' in r.json():
+        response = r.json()
+        plpy.notice(response)
+        _headers['Authorization'] = 'Bearer '+ response['access_token']
+        _headers['Content-Type'] = 'application/json'
+        _payload = { 'attributes': {'vessel_id': vessel_id} }
+        url = f'{keycloak_uri}/admin/realms/postgsail/users/{user_id}'.format(keycloak_uri,user_id)
+        #plpy.notice(url)
+        #plpy.notice(_payload)
+        data = json.dumps(_payload)
+        r = requests.put(url, headers=_headers, data=data, timeout=(5, 60))
+        if r.status_code != 204:
+            plpy.notice("Error updating user: {status} [{text}]".format(
+                status=r.status_code, text=r.text))
+            return None
+        else:
+            plpy.notice("Updated user : {user} [{text}]".format(user=user_id, text=r.text))
+    else:
+        plpy.notice(f'Error getting admin access_token: {status} [{text}]'.format(
+                status=r.status_code, text=r.text))
+    return None
+$keycloak_py$ strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+
+UPDATE public.email_templates
+	SET pushover_message='Congratulations!
+You unlocked Grafana dashboard.
+See more details at https://app.openplotter.cloud
+',email_content='Hello __RECIPIENT__,
+Congratulations! You unlocked Grafana dashboard.
+See more details at https://app.openplotter.cloud
+Happy sailing!
+Francois'
+	WHERE "name"='grafana';
+
+CREATE OR REPLACE FUNCTION public.cron_process_grafana_fn()
+ RETURNS void
+ LANGUAGE plpgsql
+AS $function$
+DECLARE
+    process_rec record;
+    data_rec record;
+    app_settings jsonb;
+    user_settings jsonb;
+BEGIN
+    -- We run grafana provisioning only after the first received vessel metadata
+    -- Check for new vessel metadata pending grafana provisioning
+    RAISE NOTICE 'cron_process_grafana_fn';
+    FOR process_rec in
+        SELECT * from process_queue
+            where channel = 'grafana' and processed is null
+            order by stored asc
+    LOOP
+        RAISE NOTICE '-> cron_process_grafana_fn [%]', process_rec.payload;
+        -- Gather url from app settings
+        app_settings := get_app_settings_fn();
+        -- Get vessel details base on metadata id
+        SELECT * INTO data_rec
+            FROM api.metadata m, auth.vessels v
+            WHERE m.id = process_rec.payload::INTEGER
+                AND m.vessel_id = v.vessel_id;
+        -- as we got data from the vessel we can do the grafana provisioning.
+        PERFORM grafana_py_fn(data_rec.name, data_rec.vessel_id, data_rec.owner_email, app_settings);
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(data_rec.vessel_id::TEXT);
+        RAISE DEBUG '-> DEBUG cron_process_grafana_fn get_user_settings_from_vesselid_fn [%]', user_settings;
+        -- add user in keycloak
+        PERFORM keycloak_auth_py_fn(data_rec.vessel_id, user_settings, app_settings);
+        -- Send notification
+        PERFORM send_notification_fn('grafana'::TEXT, user_settings::JSONB);
+        -- update process_queue entry as processed
+        UPDATE process_queue
+            SET
+                processed = NOW()
+            WHERE id = process_rec.id;
+        RAISE NOTICE '-> cron_process_grafana_fn updated process_queue table [%]', process_rec.id;
+    END LOOP;
+END;
+$function$
+;
+COMMENT ON FUNCTION public.cron_process_grafana_fn() IS 'init by pg_cron to check for new vessel pending grafana provisioning, if so perform grafana_py_fn';
+
+-- DROP FUNCTION public.grafana_py_fn(text, text, text, jsonb);
+
+CREATE OR REPLACE FUNCTION public.grafana_py_fn(_v_name text, _v_id text, _u_email text, app jsonb)
+ RETURNS void
+ TRANSFORM FOR TYPE jsonb
+ LANGUAGE plpython3u
+AS $function$
+	"""
+	https://grafana.com/docs/grafana/latest/developers/http_api/
+	Create organization base on vessel name
+	Create user base on user email
+	Add user to organization
+	Add data_source to organization
+	Add dashboard to organization
+    Update organization preferences
+	"""
+	import requests
+	import json
+	import re
+
+	grafana_uri = None
+	if 'app.grafana_admin_uri' in app and app['app.grafana_admin_uri']:
+		grafana_uri = app['app.grafana_admin_uri']
+	else:
+		plpy.error('Error no grafana_admin_uri defined, check app settings')
+		return None
+
+	b_name = None
+	if not _v_name:
+		b_name = _v_id
+	else:
+		b_name = _v_name
+
+	# add vessel org
+	headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com',
+	'Accept': 'application/json', 'Content-Type': 'application/json'}
+	path = 'api/orgs'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	data_dict = {'name':b_name}
+	data = json.dumps(data_dict)
+	r = requests.post(url, data=data, headers=headers)
+	#print(r.text)
+	plpy.notice(r.json())
+	if r.status_code == 200 and "orgId" in r.json():
+		org_id = r.json()['orgId']
+	else:
+		plpy.error('Error grafana add vessel org %', r.json())
+		return none
+
+	# add user to vessel org
+	path = 'api/admin/users'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	data_dict = {'orgId':org_id, 'email':_u_email, 'password':'asupersecretpassword'}
+	data = json.dumps(data_dict)
+	r = requests.post(url, data=data, headers=headers)
+	#print(r.text)
+	plpy.notice(r.json())
+	if r.status_code == 200 and "id" in r.json():
+		user_id = r.json()['id']
+	else:
+		plpy.error('Error grafana add user to vessel org')
+		return
+
+	# read data_source
+	path = 'api/datasources/1'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	r = requests.get(url, headers=headers)
+	#print(r.text)
+	plpy.notice(r.json())
+	data_source = r.json()
+	data_source['id'] = 0
+	data_source['orgId'] = org_id
+	data_source['uid'] = "ds_" + _v_id
+	data_source['name'] = "ds_" + _v_id
+	data_source['secureJsonData'] = {}
+	data_source['secureJsonData']['password'] = 'mysecretpassword'
+	data_source['readOnly'] = True
+	del data_source['secureJsonFields']
+
+	# add data_source to vessel org
+	path = 'api/datasources'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	data = json.dumps(data_source)
+	headers['X-Grafana-Org-Id'] = str(org_id)
+	r = requests.post(url, data=data, headers=headers)
+	plpy.notice(r.json())
+	del headers['X-Grafana-Org-Id']
+	if r.status_code != 200 and "id" not in r.json():
+		plpy.error('Error grafana add data_source to vessel org')
+		return
+
+	dashboards_tpl = [ 'pgsail_tpl_electrical', 'pgsail_tpl_logbook', 'pgsail_tpl_monitor', 'pgsail_tpl_rpi', 'pgsail_tpl_solar', 'pgsail_tpl_weather', 'pgsail_tpl_home']
+	for dashboard in dashboards_tpl:
+		# read dashboard template by uid
+		path = 'api/dashboards/uid'
+		url = f'{grafana_uri}/{path}/{dashboard}'.format(grafana_uri,path,dashboard)
+		if 'X-Grafana-Org-Id' in headers:
+			del headers['X-Grafana-Org-Id']
+		r = requests.get(url, headers=headers)
+		plpy.notice(r.json())
+		if r.status_code != 200 and "id" not in r.json():
+			plpy.error('Error grafana read dashboard template')
+			return
+		new_dashboard = r.json()
+		del new_dashboard['meta']
+		new_dashboard['dashboard']['version'] = 0
+		new_dashboard['dashboard']['id'] = 0
+		new_uid = re.sub(r'pgsail_tpl_(.*)', r'postgsail_\1', new_dashboard['dashboard']['uid'])
+		new_dashboard['dashboard']['uid'] = f'{new_uid}_{_v_id}'.format(new_uid,_v_id)
+		# add dashboard to vessel org
+		path = 'api/dashboards/db'
+		url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+		data = json.dumps(new_dashboard)
+		new_data = data.replace('PCC52D03280B7034C', data_source['uid'])
+		headers['X-Grafana-Org-Id'] = str(org_id)
+		r = requests.post(url, data=new_data, headers=headers)
+		plpy.notice(r.json())
+		if r.status_code != 200 and "id" not in r.json():
+			plpy.error('Error grafana add dashboard to vessel org')
+			return
+
+	# Update Org Prefs
+	path = 'api/org/preferences'
+	url = f'{grafana_uri}/{path}'.format(grafana_uri,path)
+	home_dashboard = {}
+	home_dashboard['timezone'] = 'utc'
+	home_dashboard['homeDashboardUID'] = f'postgsail_home_{_v_id}'.format(_v_id)
+	data = json.dumps(home_dashboard)
+	headers['X-Grafana-Org-Id'] = str(org_id)
+	r = requests.patch(url, data=data, headers=headers)
+	plpy.notice(r.json())
+	if r.status_code != 200:
+		plpy.error('Error grafana update org preferences')
+		return
+
+	plpy.notice('Done')
+$function$
+;
+
+COMMENT ON FUNCTION public.grafana_py_fn(text, text, text, jsonb) IS 'Grafana Organization,User,data_source,dashboards provisioning via HTTP API using plpython3u';
+
+UPDATE public.app_settings
+	SET value='0.6.1'
+	WHERE "name"='app.version';

initdb/99_migrations_202402.sql

@@ -0,0 +1,919 @@
+---------------------------------------------------------------------------
+-- Copyright 2021-2024 Francois Lacroix <xbgmsharp@gmail.com>
+-- This file is part of PostgSail which is released under Apache License, Version 2.0 (the "License").
+-- See file LICENSE or go to http://www.apache.org/licenses/LICENSE-2.0 for full license details.
+--
+-- Migration February 2024
+--
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+\echo 'Force timezone, just in case'
+set timezone to 'UTC';
+
+-- Update email_templates
+--INSERT INTO public.email_templates ("name",email_subject,email_content,pushover_title,pushover_message)
+--	VALUES ('windy','PostgSail Windy Weather station',E'Hello __RECIPIENT__,\nCongratulations! Your boat is now a Windy Weather station.\nSee more details at __APP_URL__/windy\nHappy sailing!\nFrancois','PostgSail Windy!',E'Congratulations!\nYour boat is now a Windy Weather station.\nSee more details at __APP_URL__/windy\n');
+--INSERT INTO public.email_templates ("name",email_subject,email_content,pushover_title,pushover_message)
+--VALUES ('alert','PostgSail Alert',E'Hello __RECIPIENT__,\nWe detected an alert __ALERT__.\nSee more details at __APP_URL__\nStay safe.\nFrancois','PostgSail Alert!',E'Congratulations!\nWe detected an alert __ALERT__.\n');
+
+INSERT INTO public.email_templates ("name",email_subject,email_content,pushover_title,pushover_message)
+	VALUES ('windy_error','PostgSail Windy Weather station Error',E'Hello __RECIPIENT__,\nSorry!We could not convert your boat into a Windy Personal Weather Station due to missing data (temp or wind).\nWindy Personal Weather Station is now disable.','PostgSail Windy error!',E'Sorry!\nWe could not convert your boat into a Windy Personal Weather Station.');
+
+-- Update app_settings
+CREATE OR REPLACE FUNCTION public.get_app_settings_fn(OUT app_settings jsonb)
+    RETURNS jsonb
+    AS $get_app_settings$
+DECLARE
+BEGIN
+    SELECT
+        jsonb_object_agg(name, value) INTO app_settings
+    FROM
+        public.app_settings
+    WHERE
+        name LIKE 'app.email%'
+        OR name LIKE 'app.pushover%'
+        OR name LIKE 'app.url'
+        OR name LIKE 'app.telegram%'
+        OR name LIKE 'app.grafana_admin_uri'
+        OR name LIKE 'app.keycloak_uri'
+        OR name LIKE 'app.windy_apikey';
+END;
+$get_app_settings$
+LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION public.get_user_settings_from_vesselid_fn(
+    IN vesselid TEXT,
+    OUT user_settings JSONB
+    ) RETURNS JSONB
+AS $get_user_settings_from_vesselid$
+    DECLARE
+    BEGIN
+        -- If vessel_id is not NULL
+        IF vesselid IS NULL OR vesselid = '' THEN
+            RAISE WARNING '-> get_user_settings_from_vesselid_fn invalid input %', vesselid;
+        END IF;
+        SELECT 
+            json_build_object( 
+                    'boat' , v.name,
+                    'recipient', a.first,
+                    'email', v.owner_email,
+                    'settings', a.preferences
+                    ) INTO user_settings
+            FROM auth.accounts a, auth.vessels v, api.metadata m
+            WHERE m.vessel_id = v.vessel_id
+                AND m.vessel_id = vesselid
+                AND a.email = v.owner_email;
+        PERFORM set_config('user.email', user_settings->>'email'::TEXT, false);
+        PERFORM set_config('user.recipient', user_settings->>'recipient'::TEXT, false);
+    END;
+$get_user_settings_from_vesselid$ LANGUAGE plpgsql;
+
+-- Create Windy PWS integration
+CREATE OR REPLACE FUNCTION public.windy_pws_py_fn(IN metric JSONB,
+    IN _user JSONB, IN app JSONB) RETURNS JSONB
+AS $windy_pws_py$
+    """
+    Send environment data from boat instruments to Windy as a Personal Weather Station (PWS)
+    https://community.windy.com/topic/8168/report-your-weather-station-data-to-windy
+    """
+    import requests
+    import json
+    import decimal
+
+    if not 'app.windy_apikey' in app and not app['app.windy_apikey']:
+        plpy.error('Error no windy_apikey defined, check app settings')
+        return none
+    if not 'station' in metric and not metric['station']:
+        plpy.error('Error no metrics defined')
+        return none
+    if not 'temp' in metric and not metric['temp']:
+        plpy.error('Error no metrics defined')
+        return none
+    if not _user:
+        plpy.error('Error no user defined, check user settings')
+        return none
+
+    _headers = {'User-Agent': 'PostgSail', 'From': 'xbgmsharp@gmail.com', 'Content-Type': 'application/json'}
+    _payload = {
+        'stations': [
+            { 'station': int(decimal.Decimal(metric['station'])),
+            'name': metric['name'],
+            'shareOption': 'Open',
+            'type': 'SignalK PostgSail Plugin',
+            'provider': 'PostgSail',
+            'url': 'https://iot.openplotter.cloud/{name}/monitoring'.format(name=metric['name']),
+            'lat': float(decimal.Decimal(metric['lat'])),
+            'lon': float(decimal.Decimal(metric['lon'])),
+            'elevation': 1 }
+        ],
+        'observations': [
+            { 'station': int(decimal.Decimal(metric['station'])),
+            'temp': float(decimal.Decimal(metric['temp'])),
+            'wind': round(float(decimal.Decimal(metric['wind']))),
+            'gust': round(float(decimal.Decimal(metric['gust']))),
+            'winddir': int(decimal.Decimal(metric['winddir'])),
+            'pressure': int(decimal.Decimal(metric['pressure'])),
+            'rh': float(decimal.Decimal(metric['rh'])) }
+    ]}
+    #print(_payload)
+    #plpy.notice(_payload)
+    data = json.dumps(_payload)
+    api_url = 'https://stations.windy.com/pws/update/{api_key}'.format(api_key=app['app.windy_apikey'])
+    r = requests.post(api_url, data=data, headers=_headers, timeout=(5, 60))
+    #print(r.text)
+    #plpy.notice(api_url)
+    if r.status_code == 200:
+        #print('Data sent successfully!')
+        plpy.notice('Data sent successfully to Windy!')
+        #plpy.notice(api_url)
+        if not 'windy' in _user['settings']:
+	        api_url = 'https://stations.windy.com/pws/station/{api_key}/{station}'.format(api_key=app['app.windy_apikey'], station=metric['station'])
+		    #print(r.text)
+		    #plpy.notice(api_url)
+	        r = requests.get(api_url, timeout=(5, 60))
+	        if r.status_code == 200:
+	            #print('Windy Personal Weather Station created successfully in Windy Stations!')
+	            plpy.notice('Windy Personal Weather Station created successfully in Windy Stations!')
+	            return r.json()
+	        else:
+	            plpy.error(f'Failed to gather PWS details. Status code: {r.status_code}')
+    else:
+        plpy.error(f'Failed to send data. Status code: {r.status_code}')
+        #print(f'Failed to send data. Status code: {r.status_code}')
+        #print(r.text)
+    return {}
+$windy_pws_py$ strict TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.windy_pws_py_fn
+    IS 'Forward vessel data to Windy as a Personal Weather Station using plpython3u';
+
+CREATE OR REPLACE FUNCTION public.cron_windy_fn() RETURNS void AS $cron_windy$
+DECLARE
+    windy_rec record;
+    default_last_metric TIMESTAMPTZ := NOW() - interval '1 day';
+    last_metric TIMESTAMPTZ;
+    metric_rec record;
+    windy_metric jsonb;
+    app_settings jsonb;
+    user_settings jsonb;
+    windy_pws jsonb;
+BEGIN
+    -- Check for new observations pending update
+    RAISE NOTICE 'cron_windy_fn';
+    -- Gather url from app settings
+    app_settings := get_app_settings_fn();
+    -- Find users with Windy active and with an active vessel
+    -- Map account id to Windy Station ID
+    FOR windy_rec in
+        SELECT
+            a.id,a.email,v.vessel_id,v.name,
+            COALESCE((a.preferences->'windy_last_metric')::TEXT, default_last_metric::TEXT) as last_metric
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels AS v ON v.owner_email = a.email
+            LEFT JOIN api.metadata AS m ON m.vessel_id = v.vessel_id
+            WHERE (a.preferences->'public_windy')::boolean = True
+                AND m.active = True
+    LOOP
+        RAISE NOTICE '-> cron_windy_fn for [%]', windy_rec;
+        PERFORM set_config('vessel.id', windy_rec.vessel_id, false);
+        --RAISE WARNING 'public.cron_process_windy_rec_fn() scheduler vessel.id %, user.id', current_setting('vessel.id', false), current_setting('user.id', false);
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(windy_rec.vessel_id::TEXT);
+        RAISE NOTICE '-> cron_windy_fn checking user_settings [%]', user_settings;
+        -- Get all metrics from the last windy_last_metric avg by 5 minutes
+        -- TODO json_agg to send all data in once, but issue with py jsonb transformation decimal. 
+        FOR metric_rec in
+            SELECT time_bucket('5 minutes', m.time) AS time_bucket,
+                    avg((m.metrics->'environment.outside.temperature')::numeric) AS temperature,
+                    avg((m.metrics->'environment.outside.pressure')::numeric) AS pressure,
+                    avg((m.metrics->'environment.outside.relativeHumidity')::numeric) AS rh,
+                    avg((m.metrics->'environment.wind.directionTrue')::numeric) AS winddir,
+                    avg((m.metrics->'environment.wind.speedTrue')::numeric) AS wind,
+                    max((m.metrics->'environment.wind.speedTrue')::numeric) AS gust,
+                    last(latitude, time) AS lat,
+                    last(longitude, time) AS lng
+                FROM api.metrics m
+                WHERE vessel_id = windy_rec.vessel_id
+                    AND m.time >= windy_rec.last_metric::TIMESTAMPTZ
+                GROUP BY time_bucket
+                ORDER BY time_bucket ASC LIMIT 100
+        LOOP
+            RAISE NOTICE '-> cron_windy_fn checking metrics [%]', metric_rec;
+            IF metric_rec.wind IS NULL OR metric_rec.temperature IS NULL THEN
+                -- Ignore when there is no metrics
+                -- Send notification
+                PERFORM send_notification_fn('windy_error'::TEXT, user_settings::JSONB);
+                -- Disable windy
+                PERFORM api.update_user_preferences_fn('{public_windy}'::TEXT, 'false'::TEXT);
+                RETURN;
+            END IF;
+            -- https://community.windy.com/topic/8168/report-your-weather-station-data-to-windy
+            -- temp from Kelvin to Celsius
+            -- winddir from radiant to Degrees
+            -- rh from ratio to percentage
+            SELECT jsonb_build_object(
+                'dateutc', metric_rec.time_bucket,
+                'station', windy_rec.id,
+                'name', windy_rec.name,
+                'lat', metric_rec.lat,
+                'lon', metric_rec.lng,
+                'wind', metric_rec.wind,
+                'gust', metric_rec.gust,
+                'pressure', metric_rec.pressure,
+                'winddir', radiantToDegrees(metric_rec.winddir::numeric),
+                'temp', kelvinToCel(metric_rec.temperature::numeric),
+                'rh', valToPercent(metric_rec.rh::numeric)
+                ) INTO windy_metric;
+            RAISE NOTICE '-> cron_windy_fn checking windy_metrics [%]', windy_metric;
+            SELECT windy_pws_py_fn(windy_metric, user_settings, app_settings) into windy_pws;
+            RAISE NOTICE '-> cron_windy_fn Windy PWS [%]', ((windy_pws->'header')::JSONB ? 'id');
+            IF NOT((user_settings->'settings')::JSONB ? 'windy') and ((windy_pws->'header')::JSONB ? 'id') then
+                RAISE NOTICE '-> cron_windy_fn new Windy PWS [%]', (windy_pws->'header')::JSONB->>'id';
+                -- Send metrics to Windy
+                PERFORM api.update_user_preferences_fn('{windy}'::TEXT, ((windy_pws->'header')::JSONB->>'id')::TEXT);
+                -- Send notification
+                PERFORM send_notification_fn('windy'::TEXT, user_settings::JSONB);
+            END IF;
+            -- Record last metrics time
+            SELECT metric_rec.time_bucket INTO last_metric;
+        END LOOP;
+        PERFORM api.update_user_preferences_fn('{windy_last_metric}'::TEXT, last_metric::TEXT);
+    END LOOP;
+END;
+$cron_windy$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_windy_fn
+    IS 'init by pg_cron to create (or update) station and uploading observations to Windy Personal Weather Station observations';
+
+CREATE OR REPLACE FUNCTION public.cron_alerts_fn() RETURNS void AS $$
+DECLARE
+    alert_rec record;
+    default_last_metric TIMESTAMPTZ := NOW() - interval '1 day';
+    last_metric TIMESTAMPTZ;
+    metric_rec record;
+    app_settings JSONB;
+    user_settings JSONB;
+    alerting JSONB;
+    _alarms JSONB;
+    alarms TEXT;
+    alert_default JSONB := '{
+        "low_pressure_threshold": 990,
+        "high_wind_speed_threshold": 30,
+        "low_water_depth_threshold": 1,
+        "min_notification_interval": 6,
+        "high_pressure_drop_threshold": 12,
+        "low_battery_charge_threshold": 90,
+        "low_battery_voltage_threshold": 12.5,
+        "low_water_temperature_threshold": 10,
+        "low_indoor_temperature_threshold": 7,
+        "low_outdoor_temperature_threshold": 3
+    }';
+BEGIN
+    -- Check for new event notification pending update
+    RAISE NOTICE 'cron_alerts_fn';
+    FOR alert_rec in
+        SELECT
+            a.user_id,a.email,v.vessel_id,
+            COALESCE((a.preferences->'alert_last_metric')::TEXT, default_last_metric::TEXT) as last_metric,
+            (alert_default || (a.preferences->'alerting')::JSONB) as alerting,
+            (a.preferences->'alarms')::JSONB as alarms
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels AS v ON v.owner_email = a.email
+            LEFT JOIN api.metadata AS m ON m.vessel_id = v.vessel_id
+            WHERE (a.preferences->'alerting'->'enabled')::boolean = True
+                AND m.active = True
+        LOOP
+        RAISE NOTICE '-> cron_alerts_fn for [%]', alert_rec;
+        PERFORM set_config('vessel.id', alert_rec.vessel_id, false);
+        PERFORM set_config('user.email', alert_rec.email, false);
+        --RAISE WARNING 'public.cron_process_alert_rec_fn() scheduler vessel.id %, user.id', current_setting('vessel.id', false), current_setting('user.id', false);
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(alert_rec.vessel_id::TEXT);
+        RAISE NOTICE '-> cron_alerts_fn checking user_settings [%]', user_settings;
+        -- Get all metrics from the last last_metric avg by 5 minutes
+        FOR metric_rec in
+            SELECT time_bucket('5 minutes', m.time) AS time_bucket,
+                    avg((m.metrics->'environment.inside.temperature')::numeric) AS intemp,
+                    avg((m.metrics->'environment.outside.temperature')::numeric) AS outtemp,
+                    avg((m.metrics->'environment.water.temperature')::numeric) AS wattemp,
+                    avg((m.metrics->'environment.depth.belowTransducer')::numeric) AS watdepth,
+                    avg((m.metrics->'environment.outside.pressure')::numeric) AS pressure,
+                    avg((m.metrics->'environment.wind.speedTrue')::numeric) AS wind,
+                    avg((m.metrics->'electrical.batteries.House.voltage')::numeric) AS voltage,
+                    avg((m.metrics->'electrical.batteries.House.capacity.stateOfCharge')::numeric) AS charge
+                FROM api.metrics m
+                WHERE vessel_id = alert_rec.vessel_id
+                    AND m.time >= alert_rec.last_metric::TIMESTAMPTZ
+                GROUP BY time_bucket
+                ORDER BY time_bucket ASC LIMIT 100
+        LOOP
+            RAISE NOTICE '-> cron_alerts_fn checking metrics [%]', metric_rec;
+            RAISE NOTICE '-> cron_alerts_fn checking alerting [%]', alert_rec.alerting;
+            --RAISE NOTICE '-> cron_alerts_fn checking debug [%] [%]', kelvinToCel(metric_rec.intemp), (alert_rec.alerting->'low_indoor_temperature_threshold');
+            IF kelvinToCel(metric_rec.intemp) < (alert_rec.alerting->'low_indoor_temperature_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_indoor_temperature_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_indoor_temperature_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_indoor_temperature_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_indoor_temperature_threshold": {"value": '|| kelvinToCel(metric_rec.intemp) ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_outdoor_temperature_threshold value:'|| kelvinToCel(metric_rec.intemp) ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_indoor_temperature_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_indoor_temperature_threshold';
+            END IF;
+            IF kelvinToCel(metric_rec.outtemp) < (alert_rec.alerting->'low_outdoor_temperature_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_outdoor_temperature_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_outdoor_temperature_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_outdoor_temperature_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_outdoor_temperature_threshold": {"value": '|| kelvinToCel(metric_rec.outtemp) ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_outdoor_temperature_threshold value:'|| kelvinToCel(metric_rec.outtemp) ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_outdoor_temperature_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_outdoor_temperature_threshold';
+            END IF;
+            IF kelvinToCel(metric_rec.wattemp) < (alert_rec.alerting->'low_water_temperature_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_water_temperature_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_water_temperature_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_water_temperature_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_water_temperature_threshold": {"value": '|| kelvinToCel(metric_rec.wattemp) ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_water_temperature_threshold value:'|| kelvinToCel(metric_rec.wattemp) ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_water_temperature_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_water_temperature_threshold';
+            END IF;
+            IF metric_rec.watdepth < (alert_rec.alerting->'low_water_depth_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_water_depth_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_water_depth_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_water_depth_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_water_depth_threshold": {"value": '|| metric_rec.watdepth ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_water_depth_threshold value:'|| metric_rec.watdepth ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_water_depth_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_water_depth_threshold';
+            END IF;
+            if metric_rec.pressure < (alert_rec.alerting->'high_pressure_drop_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'high_pressure_drop_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'high_pressure_drop_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'high_pressure_drop_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"high_pressure_drop_threshold": {"value": '|| metric_rec.pressure ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "high_pressure_drop_threshold value:'|| metric_rec.pressure ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug high_pressure_drop_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug high_pressure_drop_threshold';
+            END IF;
+            IF metric_rec.wind > (alert_rec.alerting->'high_wind_speed_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'high_wind_speed_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'high_wind_speed_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'high_wind_speed_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"high_wind_speed_threshold": {"value": '|| metric_rec.wind ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "high_wind_speed_threshold value:'|| metric_rec.wind ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug high_wind_speed_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug high_wind_speed_threshold';
+            END IF;
+            if metric_rec.voltage < (alert_rec.alerting->'low_battery_voltage_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_battery_voltage_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = 'lacroix.francois@gmail.com';
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_battery_voltage_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_battery_voltage_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_battery_voltage_threshold": {"value": '|| metric_rec.voltage ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_battery_voltage_threshold value:'|| metric_rec.voltage ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_battery_voltage_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_battery_voltage_threshold';
+            END IF;
+            if (metric_rec.charge*100) < (alert_rec.alerting->'low_battery_charge_threshold')::numeric then
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', (alert_rec.alarms->'low_battery_charge_threshold'->>'date')::TIMESTAMPTZ;
+                RAISE NOTICE '-> cron_alerts_fn checking debug [%]', metric_rec.time_bucket::TIMESTAMPTZ;
+                -- Get latest alarms
+                SELECT preferences->'alarms' INTO _alarms FROM auth.accounts a WHERE a.email = current_setting('user.email', false);
+                -- Is alarm in the min_notification_interval time frame
+                IF (
+                    ((_alarms->'low_battery_charge_threshold'->>'date') IS NULL) OR
+                    (((_alarms->'low_battery_charge_threshold'->>'date')::TIMESTAMPTZ
+                    + ((interval '1 hour') * (alert_rec.alerting->>'min_notification_interval')::NUMERIC))
+                    < metric_rec.time_bucket::TIMESTAMPTZ)
+                    ) THEN
+                    -- Add alarm
+                    alarms := '{"low_battery_charge_threshold": {"value": '|| (metric_rec.charge*100) ||', "date":"' || metric_rec.time_bucket || '"}}';
+                    -- Merge alarms
+                    SELECT public.jsonb_recursive_merge(_alarms::jsonb, alarms::jsonb) into _alarms;
+                    -- Update alarms for user
+                    PERFORM api.update_user_preferences_fn('{alarms}'::TEXT, _alarms::TEXT);
+                    -- Gather user settings
+                    user_settings := get_user_settings_from_vesselid_fn(current_setting('vessel.id', false));
+                    SELECT user_settings::JSONB || ('{"alert": "low_battery_charge_threshold value:'|| (metric_rec.charge*100) ||'"}'::text)::JSONB into user_settings;
+                    -- Send notification
+                    PERFORM send_notification_fn('alert'::TEXT, user_settings::JSONB);
+                    -- DEBUG
+                    RAISE NOTICE '-> cron_alerts_fn checking debug low_battery_charge_threshold +interval';
+                END IF;
+                RAISE NOTICE '-> cron_alerts_fn checking debug low_battery_charge_threshold';
+            END IF;
+            -- Record last metrics time
+            SELECT metric_rec.time_bucket INTO last_metric;
+        END LOOP;
+        PERFORM api.update_user_preferences_fn('{alert_last_metric}'::TEXT, last_metric::TEXT);
+    END LOOP;
+END;
+$$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_alerts_fn
+    IS 'init by pg_cron to check for alerts';
+
+-- CRON for no vessel notification
+CREATE FUNCTION public.cron_no_vessel_fn() RETURNS void AS $no_vessel$
+DECLARE
+    no_vessel record;
+    user_settings jsonb;
+BEGIN
+    -- Check for user with no vessel register
+    RAISE NOTICE 'cron_no_vessel_fn';
+    FOR no_vessel in
+        SELECT a.user_id,a.email,a.first
+            FROM auth.accounts a
+            WHERE NOT EXISTS (
+                SELECT *
+                FROM auth.vessels v
+                WHERE v.owner_email = a.email)
+    LOOP
+        RAISE NOTICE '-> cron_no_vessel_rec_fn for [%]', no_vessel;
+        SELECT json_build_object('email', no_vessel.email, 'recipient', no_vessel.first) into user_settings;
+        RAISE NOTICE '-> debug cron_no_vessel_rec_fn [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('no_vessel'::TEXT, user_settings::JSONB);
+    END LOOP;
+END;
+$no_vessel$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_no_vessel_fn
+    IS 'init by pg_cron, check for user with no vessel register then send notification';
+
+CREATE FUNCTION public.cron_no_metadata_fn() RETURNS void AS $no_metadata$
+DECLARE
+    no_metadata_rec record;
+    user_settings jsonb;
+BEGIN
+    -- Check for vessel register but with no metadata
+    RAISE NOTICE 'cron_no_metadata_fn';
+    FOR no_metadata_rec in
+        SELECT
+            a.user_id,a.email,a.first
+            FROM auth.accounts a, auth.vessels v
+            WHERE NOT EXISTS (
+                SELECT *
+                FROM  api.metadata m
+                WHERE v.vessel_id = m.vessel_id) AND v.owner_email = a.email
+    LOOP
+        RAISE NOTICE '-> cron_process_no_metadata_rec_fn for [%]', no_metadata_rec;
+        SELECT json_build_object('email', no_metadata_rec.email, 'recipient', no_metadata_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_no_metadata_rec_fn [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('no_metadata'::TEXT, user_settings::JSONB);
+    END LOOP;
+END;
+$no_metadata$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_no_metadata_fn
+    IS 'init by pg_cron, check for vessel with no metadata then send notification';
+
+CREATE FUNCTION public.cron_no_activity_fn() RETURNS void AS $no_activity$
+DECLARE
+    no_activity_rec record;
+    user_settings jsonb;
+BEGIN
+    -- Check for vessel with no activity for more than 230 days
+    RAISE NOTICE 'cron_no_activity_fn';
+    FOR no_activity_rec in
+        SELECT
+            v.owner_email,m.name,m.vessel_id,m.time,a.first
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels v ON v.owner_email = a.email
+            LEFT JOIN api.metadata m ON v.vessel_id = m.vessel_id
+            WHERE m.time < NOW() AT TIME ZONE 'UTC' - INTERVAL '230 DAYS'
+    LOOP
+        RAISE NOTICE '-> cron_process_no_activity_rec_fn for [%]', no_activity_rec;
+        SELECT json_build_object('email', no_activity_rec.owner_email, 'recipient', no_activity_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_no_activity_rec_fn [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('no_activity'::TEXT, user_settings::JSONB);
+    END LOOP;
+END;
+$no_activity$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_no_activity_fn
+    IS 'init by pg_cron, check for vessel with no activity for more than 230 days then send notification';
+
+CREATE FUNCTION public.cron_deactivated_fn() RETURNS void AS $deactivated$
+DECLARE
+    no_activity_rec record;
+    user_settings jsonb;
+BEGIN
+    RAISE NOTICE 'cron_deactivated_fn';
+
+    -- List accounts with vessel inactivity for more than 1 YEAR
+    FOR no_activity_rec in
+        SELECT
+            v.owner_email,m.name,m.vessel_id,m.time,a.first
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels v ON v.owner_email = a.email
+            LEFT JOIN api.metadata m ON v.vessel_id = m.vessel_id
+            WHERE m.time < NOW() AT TIME ZONE 'UTC' - INTERVAL '1 YEAR'
+    LOOP
+        RAISE NOTICE '-> cron_process_deactivated_rec_fn for inactivity [%]', no_activity_rec;
+        SELECT json_build_object('email', no_activity_rec.owner_email, 'recipient', no_activity_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_deactivated_rec_fn inactivity [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('deactivated'::TEXT, user_settings::JSONB);
+        --PERFORM public.delete_account_fn(no_activity_rec.owner_email::TEXT, no_activity_rec.vessel_id::TEXT);
+    END LOOP;
+
+    -- List accounts with no vessel metadata for more than 1 YEAR
+    FOR no_activity_rec in
+        SELECT
+            a.user_id,a.email,a.first,a.created_at
+            FROM auth.accounts a, auth.vessels v
+            WHERE NOT EXISTS (
+                SELECT *
+                FROM  api.metadata m
+                WHERE v.vessel_id = m.vessel_id) AND v.owner_email = a.email
+            AND v.created_at < NOW() AT TIME ZONE 'UTC' - INTERVAL '1 YEAR'
+    LOOP
+        RAISE NOTICE '-> cron_process_deactivated_rec_fn for no metadata [%]', no_activity_rec;
+        SELECT json_build_object('email', no_activity_rec.owner_email, 'recipient', no_activity_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_deactivated_rec_fn no metadata [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('deactivated'::TEXT, user_settings::JSONB);
+        --PERFORM public.delete_account_fn(no_activity_rec.owner_email::TEXT, no_activity_rec.vessel_id::TEXT);
+    END LOOP;
+
+    -- List accounts with no vessel created for more than 1 YEAR
+    FOR no_activity_rec in
+        SELECT a.user_id,a.email,a.first,a.created_at
+            FROM auth.accounts a
+            WHERE NOT EXISTS (
+                SELECT *
+                FROM auth.vessels v
+                WHERE v.owner_email = a.email)
+            AND a.created_at < NOW() AT TIME ZONE 'UTC' - INTERVAL '1 YEAR'
+    LOOP
+        RAISE NOTICE '-> cron_process_deactivated_rec_fn for no vessel [%]', no_activity_rec;
+        SELECT json_build_object('email', no_activity_rec.owner_email, 'recipient', no_activity_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_deactivated_rec_fn no vessel [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('deactivated'::TEXT, user_settings::JSONB);
+        --PERFORM public.delete_account_fn(no_activity_rec.owner_email::TEXT, no_activity_rec.vessel_id::TEXT);
+    END LOOP;
+END;
+$deactivated$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_deactivated_fn
+    IS 'init by pg_cron, check for vessel with no activity for more than 1 year then send notification and delete data';
+
+DROP FUNCTION IF EXISTS public.cron_prune_otp_fn;
+CREATE OR REPLACE FUNCTION public.cron_prune_otp_fn() RETURNS void
+AS $$
+    DECLARE
+        otp_rec record;
+    BEGIN
+        -- Purge OTP older than 15 minutes
+        RAISE NOTICE 'cron_prune_otp_fn';
+        FOR otp_rec in
+            SELECT *
+            FROM auth.otp
+            WHERE otp_timestamp < NOW() AT TIME ZONE 'UTC' - INTERVAL '15 MINUTES'
+            ORDER BY otp_timestamp desc
+        LOOP
+            RAISE NOTICE '-> cron_prune_otp_fn deleting expired otp for user [%]', otp_rec.user_email;
+            -- remove entry
+            DELETE FROM auth.otp
+                WHERE user_email = otp_rec.user_email;
+            RAISE NOTICE '-> cron_prune_otp_fn deleted expire otp for user [%]', otp_rec.user_email;
+        END LOOP;
+    END;
+$$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_prune_otp_fn
+    IS 'init by pg_cron to purge older than 15 minutes OTP token';
+
+DROP FUNCTION IF EXISTS public.cron_process_prune_otp_fn();
+DROP FUNCTION IF EXISTS public.cron_process_no_vessel_fn();
+DROP FUNCTION IF EXISTS public.cron_process_no_metadata_fn();
+DROP FUNCTION IF EXISTS public.cron_process_no_activity_fn();
+DROP FUNCTION IF EXISTS public.cron_process_deactivated_fn();
+DROP FUNCTION IF EXISTS public.cron_process_windy_fn();
+DROP FUNCTION IF EXISTS public.cron_process_alerts_fn();
+
+-- Remove deprecated fn
+DROP FUNCTION IF EXISTS public.cron_process_new_account_fn();
+DROP FUNCTION IF EXISTS public.cron_process_new_account_otp_validation_fn();
+DROP FUNCTION IF EXISTS public.cron_process_new_moorage_fn();
+DROP FUNCTION IF EXISTS public.cron_process_new_vessel_fn();
+
+CREATE OR REPLACE FUNCTION send_notification_fn(
+    IN email_type TEXT,
+    IN user_settings JSONB) RETURNS VOID
+AS $send_notification$
+    DECLARE
+        app_settings JSONB;
+        _email_notifications BOOLEAN := False;
+        _phone_notifications BOOLEAN := False;
+        _pushover_user_key TEXT := NULL;
+        pushover_settings JSONB := NULL;
+        _telegram_notifications BOOLEAN := False;
+        _telegram_chat_id TEXT := NULL;
+        telegram_settings JSONB := NULL;
+		_email TEXT := NULL;
+    BEGIN
+        -- TODO input check
+        --RAISE NOTICE '--> send_notification_fn type [%]', email_type;
+        -- Gather notification app settings, eg: email, pushover, telegram
+        app_settings := get_app_settings_fn();
+        --RAISE NOTICE '--> send_notification_fn app_settings [%]', app_settings;
+        --RAISE NOTICE '--> user_settings [%]', user_settings->>'email'::TEXT;
+
+        -- Gather notifications settings and merge with user settings
+        -- Send notification email
+        SELECT preferences['email_notifications'] INTO _email_notifications
+            FROM auth.accounts a
+            WHERE a.email = user_settings->>'email'::TEXT;
+        RAISE NOTICE '--> send_notification_fn email_notifications [%]', _email_notifications;
+        -- If email server app settings set and if email user settings set
+        IF app_settings['app.email_server'] IS NOT NULL AND _email_notifications IS True THEN
+            PERFORM send_email_py_fn(email_type::TEXT, user_settings::JSONB, app_settings::JSONB);
+        END IF;
+
+        -- Send notification pushover
+        SELECT preferences['phone_notifications'],preferences->>'pushover_user_key' INTO _phone_notifications,_pushover_user_key
+            FROM auth.accounts a
+            WHERE a.email = user_settings->>'email'::TEXT;
+        RAISE NOTICE '--> send_notification_fn phone_notifications [%]', _phone_notifications;
+        -- If pushover app settings set and if pushover user settings set
+        IF app_settings['app.pushover_app_token'] IS NOT NULL AND _phone_notifications IS True AND _pushover_user_key IS NOT NULL THEN
+            SELECT json_build_object('pushover_user_key', _pushover_user_key) into pushover_settings;
+            SELECT user_settings::JSONB || pushover_settings::JSONB into user_settings;
+            --RAISE NOTICE '--> send_notification_fn user_settings + pushover [%]', user_settings;
+            PERFORM send_pushover_py_fn(email_type::TEXT, user_settings::JSONB, app_settings::JSONB);
+        END IF;
+
+        -- Send notification telegram
+        SELECT (preferences->'telegram'->'chat'->'id') IS NOT NULL,preferences['telegram']['chat']['id'] INTO _telegram_notifications,_telegram_chat_id
+            FROM auth.accounts a
+            WHERE a.email = user_settings->>'email'::TEXT;
+        RAISE NOTICE '--> send_notification_fn telegram_notifications [%]', _telegram_notifications;
+        -- If telegram app settings set and if telegram user settings set
+        IF app_settings['app.telegram_bot_token'] IS NOT NULL AND _telegram_notifications IS True AND _phone_notifications IS True THEN
+            SELECT json_build_object('telegram_chat_id', _telegram_chat_id) into telegram_settings;
+            SELECT user_settings::JSONB || telegram_settings::JSONB into user_settings;
+            --RAISE NOTICE '--> send_notification_fn user_settings + telegram [%]', user_settings;
+            PERFORM send_telegram_py_fn(email_type::TEXT, user_settings::JSONB, app_settings::JSONB);
+        END IF;
+    END;
+$send_notification$ LANGUAGE plpgsql;
+
+-- fn to trim new vessel name
+CREATE FUNCTION new_vessel_trim_fn() RETURNS trigger AS $new_vessel_trim_fn$
+BEGIN
+    NEW.name := TRIM(NEW.name);
+    RETURN NEW;
+END;
+$new_vessel_trim_fn$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.new_vessel_trim_fn
+    IS 'Trim space vessel name';
+-- Trigger trim new vessel name
+CREATE TRIGGER new_vessel_trim BEFORE INSERT ON auth.vessels
+    FOR EACH ROW EXECUTE FUNCTION public.new_vessel_trim_fn();
+-- Description
+COMMENT ON TRIGGER new_vessel_trim
+  ON auth.vessels
+  IS 'Trim space vessel name';
+
+CREATE or REPLACE FUNCTION public.logbook_update_geojson_fn(IN _id integer, IN _start text, IN _end text,
+    OUT _track_geojson JSON
+ ) AS $logbook_geojson$
+    declare
+     log_geojson jsonb;
+     metrics_geojson jsonb;
+     _map jsonb;
+    begin
+        -- GeoJson Feature Logbook linestring
+        SELECT
+            ST_AsGeoJSON(log.*) into log_geojson
+        FROM
+           ( SELECT
+                id,name,
+                distance,
+                duration,
+                avg_speed,
+                max_speed,
+                max_wind_speed,
+                _from_time,
+                _to_time
+                _from_moorage_id,
+                _to_moorage_id,
+                notes,
+                track_geom
+                FROM api.logbook
+                WHERE id = _id
+           ) AS log;
+        -- GeoJson Feature Metrics point
+        SELECT
+            json_agg(ST_AsGeoJSON(t.*)::json) into metrics_geojson
+        FROM (
+            ( SELECT
+                time,
+                courseovergroundtrue,
+                speedoverground,
+                windspeedapparent,
+                longitude,latitude,
+                '' AS notes,
+                coalesce(metrics->'environment.wind.speedTrue', null) as truewindspeed,
+                coalesce(metrics->'environment.wind.directionTrue', null) as truewinddirection,
+                coalesce(status, null) as status,
+                st_makepoint(longitude,latitude) AS geo_point
+                FROM api.metrics m
+                WHERE m.latitude IS NOT NULL
+                    AND m.longitude IS NOT NULL
+                    AND time >= _start::TIMESTAMPTZ
+                    AND time <= _end::TIMESTAMPTZ
+                    AND vessel_id = current_setting('vessel.id', false)
+                ORDER BY m.time ASC
+            )
+        ) AS t;
+
+        -- Merge jsonb
+        SELECT log_geojson::jsonb || metrics_geojson::jsonb into _map;
+        -- output
+        SELECT
+            json_build_object(
+                'type', 'FeatureCollection',
+                'features', _map
+            ) into _track_geojson;
+    END;
+$logbook_geojson$ LANGUAGE plpgsql;
+
+-- Update version
+UPDATE public.app_settings
+	SET value='0.7.0'
+	WHERE "name"='app.version';
+
+-- Create a cron job
+\c postgres
+
+UPDATE cron.job
+	SET command='select public.cron_prune_otp_fn()'
+	WHERE jobname = 'cron_prune_otp';
+UPDATE cron.job
+	SET command='select public.cron_no_vessel_fn()'
+	WHERE jobname = 'cron_no_vessel';
+UPDATE cron.job
+	SET command='select public.cron_no_metadata_fn()'
+	WHERE jobname = 'cron_no_metadata';
+UPDATE cron.job
+	SET command='select public.cron_no_activity_fn()'
+	WHERE jobname = 'cron_no_activity';
+UPDATE cron.job
+	SET command='select public.cron_windy_fn()'
+	WHERE jobname = 'cron_windy';
+UPDATE cron.job
+	SET command='select public.cron_alerts_fn()'
+	WHERE jobname = 'cron_alerts';
+

initdb/99_migrations_202403.sql

@@ -0,0 +1,528 @@
+---------------------------------------------------------------------------
+-- Copyright 2021-2024 Francois Lacroix <xbgmsharp@gmail.com>
+-- This file is part of PostgSail which is released under Apache License, Version 2.0 (the "License").
+-- See file LICENSE or go to http://www.apache.org/licenses/LICENSE-2.0 for full license details.
+--
+-- Migration March 2024
+--
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+\echo 'Force timezone, just in case'
+set timezone to 'UTC';
+
+CREATE OR REPLACE FUNCTION public.process_lat_lon_fn(IN lon NUMERIC, IN lat NUMERIC,
+    OUT moorage_id INTEGER,
+    OUT moorage_type INTEGER,
+    OUT moorage_name TEXT,
+    OUT moorage_country TEXT
+) AS $process_lat_lon$
+    DECLARE
+        stay_rec record;
+        --moorage_id INTEGER := NULL;
+        --moorage_type INTEGER := 1; -- Unknown
+        --moorage_name TEXT := NULL;
+        --moorage_country TEXT := NULL;
+        existing_rec record;
+        geo jsonb;
+        overpass jsonb;
+    BEGIN
+        RAISE NOTICE '-> process_lat_lon_fn';
+        IF lon IS NULL OR lat IS NULL THEN
+            RAISE WARNING '-> process_lat_lon_fn invalid input lon %, lat %', lon, lat;
+            --return NULL;
+        END IF;
+
+        -- Do we have an existing moorages within 300m of the new stay
+        FOR existing_rec in
+            SELECT
+                *
+            FROM api.moorages m
+            WHERE
+                m.latitude IS NOT NULL
+                AND m.longitude IS NOT NULL
+                AND m.geog IS NOT NULL
+                AND ST_DWithin(
+                    Geography(ST_MakePoint(m.longitude, m.latitude)),
+                    Geography(ST_MakePoint(lon, lat)),
+                    300 -- in meters
+                    )
+                AND m.vessel_id = current_setting('vessel.id', false)
+            ORDER BY id ASC
+        LOOP
+            -- found previous stay within 300m of the new moorage
+            IF existing_rec.id IS NOT NULL AND existing_rec.id > 0 THEN
+                RAISE NOTICE '-> process_lat_lon_fn found previous moorages within 300m %', existing_rec;
+                EXIT; -- exit loop
+            END IF;
+        END LOOP;
+
+        -- if with in 300m use existing name and stay_code
+        -- else insert new entry
+        IF existing_rec.id IS NOT NULL AND existing_rec.id > 0 THEN
+            RAISE NOTICE '-> process_lat_lon_fn found close by moorage using existing name and stay_code %', existing_rec;
+            moorage_id := existing_rec.id;
+            moorage_name := existing_rec.name;
+            moorage_type := existing_rec.stay_code;
+        ELSE
+            RAISE NOTICE '-> process_lat_lon_fn create new moorage';
+            -- query overpass api to guess moorage type
+            overpass := overpass_py_fn(lon::NUMERIC, lat::NUMERIC);
+            RAISE NOTICE '-> process_lat_lon_fn overpass name:[%] seamark:type:[%]', overpass->'name', overpass->'seamark:type';
+            moorage_type = 1; -- Unknown
+            IF overpass->>'seamark:type' = 'harbour' AND overpass->>'seamark:harbour:category' = 'marina' then
+                moorage_type = 4; -- Dock
+            ELSIF overpass->>'seamark:type' = 'mooring' AND overpass->>'seamark:mooring:category' = 'buoy' then
+                moorage_type = 3; -- Mooring Buoy
+            ELSIF overpass->>'seamark:type' ~ '(anchorage|anchor_berth|berth)' OR overpass->>'natural' ~ '(bay|beach)' then
+                moorage_type = 2; -- Anchor
+            ELSIF overpass->>'seamark:type' = 'mooring' then
+                moorage_type = 3; -- Mooring Buoy
+            ELSIF overpass->>'leisure' = 'marina' then
+                moorage_type = 4; -- Dock
+            END IF;
+            -- geo reverse _lng _lat
+            geo := reverse_geocode_py_fn('nominatim', lon::NUMERIC, lat::NUMERIC);
+            moorage_country := geo->>'country_code';
+            IF overpass->>'name:en' IS NOT NULL then
+                moorage_name = overpass->>'name:en';
+            ELSIF overpass->>'name' IS NOT NULL then
+                moorage_name = overpass->>'name';
+            ELSE
+                moorage_name := geo->>'name';
+            END IF;
+            RAISE NOTICE '-> process_lat_lon_fn output name:[%] type:[%]', moorage_name, moorage_type;
+            RAISE NOTICE '-> process_lat_lon_fn insert new moorage for [%] name:[%] type:[%]', current_setting('vessel.id', false), moorage_name, moorage_type;
+            -- Insert new moorage from stay
+            INSERT INTO api.moorages
+                (vessel_id, name, country, stay_code, reference_count, latitude, longitude, geog, overpass, nominatim)
+                VALUES (
+                    current_setting('vessel.id', false),
+                    coalesce(moorage_name, null),
+                    coalesce(moorage_country, null),
+                    moorage_type,
+                    1,
+                    lat,
+                    lon,
+                    Geography(ST_MakePoint(lon, lat)),
+                    coalesce(overpass, null),
+                    coalesce(geo, null)
+                ) returning id into moorage_id;
+            -- Add moorage entry to process queue for reference
+            --INSERT INTO process_queue (channel, payload, stored, ref_id, processed)
+            --    VALUES ('new_moorage', moorage_id, now(), current_setting('vessel.id', true), now());
+        END IF;
+        --return json_build_object(
+        --        'id', moorage_id,
+        --        'name', moorage_name,
+        --        'type', moorage_type
+        --        )::jsonb;
+    END;
+$process_lat_lon$ LANGUAGE plpgsql;
+
+CREATE or replace FUNCTION public.logbook_update_geojson_fn(IN _id integer, IN _start text, IN _end text,
+    OUT _track_geojson JSON
+ ) AS $logbook_geojson$
+    declare
+     log_geojson jsonb;
+     metrics_geojson jsonb;
+     _map jsonb;
+    begin
+        -- GeoJson Feature Logbook linestring
+        SELECT
+            ST_AsGeoJSON(log.*) into log_geojson
+        FROM
+           ( SELECT
+                id,name,
+                distance,
+                duration,
+                avg_speed,
+                max_speed,
+                max_wind_speed,
+                _from_time,
+                _to_time
+                _from_moorage_id,
+                _to_moorage_id,
+                notes,
+                track_geom
+                FROM api.logbook
+                WHERE id = _id
+           ) AS log;
+        -- GeoJson Feature Metrics point
+        SELECT
+            json_agg(ST_AsGeoJSON(t.*)::json) into metrics_geojson
+        FROM (
+            ( SELECT
+                time,
+                courseovergroundtrue,
+                speedoverground,
+                windspeedapparent,
+                longitude,latitude,
+                '' AS notes,
+                coalesce(metersToKnots((metrics->'environment.wind.speedTrue')::NUMERIC), null) as truewindspeed,
+                coalesce(radiantToDegrees((metrics->'environment.wind.directionTrue')::NUMERIC), null) as truewinddirection,
+                coalesce(status, null) as status,
+                st_makepoint(longitude,latitude) AS geo_point
+                FROM api.metrics m
+                WHERE m.latitude IS NOT NULL
+                    AND m.longitude IS NOT NULL
+                    AND time >= _start::TIMESTAMPTZ
+                    AND time <= _end::TIMESTAMPTZ
+                    AND vessel_id = current_setting('vessel.id', false)
+                ORDER BY m.time ASC
+            )
+        ) AS t;
+
+        -- Merge jsonb
+        SELECT log_geojson::jsonb || metrics_geojson::jsonb into _map;
+        -- output
+        SELECT
+            json_build_object(
+                'type', 'FeatureCollection',
+                'features', _map
+            ) into _track_geojson;
+    END;
+$logbook_geojson$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION public.metersToKnots(IN meters NUMERIC)
+RETURNS NUMERIC
+AS $$
+BEGIN
+    RETURN ROUND(((meters * 1.9438445) * 10) / 10, 2);
+END
+$$
+LANGUAGE plpgsql IMMUTABLE;
+-- Description
+COMMENT ON FUNCTION
+    public.metersToKnots
+    IS 'convert speed meters/s To Knots';
+
+CREATE OR REPLACE FUNCTION logbook_update_extra_json_fn(IN _id integer, IN _start text, IN _end text,
+    OUT _extra_json JSON
+    ) AS $logbook_extra_json$
+    declare
+        obs_json jsonb default '{ "seaState": -1, "cloudCoverage": -1, "visibility": -1}'::jsonb;
+        log_json jsonb default '{}'::jsonb;
+        runtime_json jsonb default '{}'::jsonb;
+        metrics_json jsonb default '{}'::jsonb;
+        metric_rec record;
+    BEGIN
+        -- Calculate 'navigation.log' metrics
+        WITH
+            start_trip as (
+                -- Fetch 'navigation.log' start, first entry
+                SELECT key, value
+                FROM api.metrics m,
+                        jsonb_each_text(m.metrics)
+                WHERE key ILIKE 'navigation.log'
+                    AND time = _start::TIMESTAMPTZ
+                    AND vessel_id = current_setting('vessel.id', false)
+            ),
+            end_trip as (
+                -- Fetch 'navigation.log' end, last entry
+                SELECT key, value
+                FROM api.metrics m,
+                        jsonb_each_text(m.metrics)
+                WHERE key ILIKE 'navigation.log'
+                    AND time = _end::TIMESTAMPTZ
+                    AND vessel_id = current_setting('vessel.id', false)
+            ),
+            nm as (
+                -- calculate distance and convert meter to nautical miles
+                SELECT ((end_trip.value::NUMERIC - start_trip.value::numeric) * 0.00053996) as trip from start_trip,end_trip
+            )
+        -- Generate JSON
+        SELECT jsonb_build_object('navigation.log', trip) INTO log_json FROM nm;
+        RAISE NOTICE '-> logbook_update_extra_json_fn navigation.log: %', log_json;
+
+        -- Calculate engine hours from propulsion.%.runTime first entry
+        FOR metric_rec IN
+            SELECT key, value
+                FROM api.metrics m,
+                        jsonb_each_text(m.metrics)
+                WHERE key ILIKE 'propulsion.%.runTime'
+                    AND time = _start::TIMESTAMPTZ
+                    AND vessel_id = current_setting('vessel.id', false)
+        LOOP
+            -- Engine Hours in seconds
+            RAISE NOTICE '-> logbook_update_extra_json_fn propulsion.*.runTime: %', metric_rec;
+            with
+            end_runtime AS (
+                -- Fetch 'propulsion.*.runTime' last entry
+                SELECT key, value
+                    FROM api.metrics m,
+                            jsonb_each_text(m.metrics)
+                    WHERE key ILIKE metric_rec.key
+                        AND time = _end::TIMESTAMPTZ
+                        AND vessel_id = current_setting('vessel.id', false)
+            ),
+            runtime AS (
+                -- calculate runTime Engine Hours as ISO duration
+                --SELECT (end_runtime.value::numeric - metric_rec.value::numeric) AS value FROM end_runtime
+                SELECT (((end_runtime.value::numeric - metric_rec.value::numeric) / 3600) * '1 hour'::interval)::interval as value FROM end_runtime
+            )
+            -- Generate JSON
+            SELECT jsonb_build_object(metric_rec.key, runtime.value) INTO runtime_json FROM runtime;
+            RAISE NOTICE '-> logbook_update_extra_json_fn key: %, value: %', metric_rec.key, runtime_json;
+        END LOOP;
+
+        -- Update logbook with extra value and return json
+        SELECT COALESCE(log_json::JSONB, '{}'::jsonb) || COALESCE(runtime_json::JSONB, '{}'::jsonb) INTO metrics_json;
+        SELECT jsonb_build_object('metrics', metrics_json, 'observations', obs_json) INTO _extra_json;
+        RAISE NOTICE '-> logbook_update_extra_json_fn log_json: %, runtime_json: %, _extra_json: %', log_json, runtime_json, _extra_json;
+    END;
+$logbook_extra_json$ LANGUAGE plpgsql;
+
+DROP FUNCTION IF EXISTS public.logbook_update_gpx_fn();
+
+CREATE OR REPLACE FUNCTION metadata_upsert_trigger_fn() RETURNS trigger AS $metadata_upsert$
+    DECLARE
+        metadata_id integer;
+        metadata_active boolean;
+    BEGIN
+        -- Set client_id to new value to allow RLS
+        --PERFORM set_config('vessel.client_id', NEW.client_id, false);
+        -- UPSERT - Insert vs Update for Metadata
+        --RAISE NOTICE 'metadata_upsert_trigger_fn';
+        --PERFORM set_config('vessel.id', NEW.vessel_id, true);
+        --RAISE WARNING 'metadata_upsert_trigger_fn [%] [%]', current_setting('vessel.id', true), NEW;
+        SELECT m.id,m.active INTO metadata_id, metadata_active
+            FROM api.metadata m
+            WHERE m.vessel_id IS NOT NULL AND m.vessel_id = current_setting('vessel.id', true);
+        --RAISE NOTICE 'metadata_id is [%]', metadata_id;
+        IF metadata_id IS NOT NULL THEN
+            -- send notification if boat is back online
+            IF metadata_active is False THEN
+                -- Add monitor online entry to process queue for later notification
+                INSERT INTO process_queue (channel, payload, stored, ref_id)
+                    VALUES ('monitoring_online', metadata_id, now(), current_setting('vessel.id', true));
+            END IF;
+            -- Update vessel metadata
+            UPDATE api.metadata
+                SET
+                    name = NEW.name,
+                    mmsi = NEW.mmsi,
+                    client_id = NEW.client_id,
+                    length = NEW.length,
+                    beam = NEW.beam,
+                    height = NEW.height,
+                    ship_type = NEW.ship_type,
+                    plugin_version = NEW.plugin_version,
+                    signalk_version = NEW.signalk_version,
+                    platform = REGEXP_REPLACE(NEW.platform, '[^a-zA-Z0-9\(\) ]', '', 'g'),
+                    configuration = NEW.configuration,
+                    -- time = NEW.time, ignore the time sent by the vessel as it is out of sync sometimes.
+                    time = NOW(), -- overwrite the time sent by the vessel
+                    active = true
+                WHERE id = metadata_id;
+            RETURN NULL; -- Ignore insert
+        ELSE
+            IF NEW.vessel_id IS NULL THEN
+                -- set vessel_id from jwt if not present in INSERT query
+                NEW.vessel_id := current_setting('vessel.id');
+            END IF;
+            -- Ignore and overwrite the time sent by the vessel
+            NEW.time := NOW();
+            -- Insert new vessel metadata
+            RETURN NEW; -- Insert new vessel metadata
+        END IF;
+    END;
+$metadata_upsert$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION public.cron_windy_fn() RETURNS void AS $$
+DECLARE
+    windy_rec record;
+    default_last_metric TIMESTAMPTZ := NOW() - interval '1 day';
+    last_metric TIMESTAMPTZ := NOW();
+    metric_rec record;
+    windy_metric jsonb;
+    app_settings jsonb;
+    user_settings jsonb;
+    windy_pws jsonb;
+BEGIN
+    -- Check for new observations pending update
+    RAISE NOTICE 'cron_process_windy_fn';
+    -- Gather url from app settings
+    app_settings := get_app_settings_fn();
+    -- Find users with Windy active and with an active vessel
+    -- Map account id to Windy Station ID
+    FOR windy_rec in
+        SELECT
+            a.id,a.email,v.vessel_id,v.name,
+            COALESCE((a.preferences->'windy_last_metric')::TEXT, default_last_metric::TEXT) as last_metric
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels AS v ON v.owner_email = a.email
+            LEFT JOIN api.metadata AS m ON m.vessel_id = v.vessel_id
+            WHERE (a.preferences->'public_windy')::boolean = True
+                AND m.active = True
+    LOOP
+        RAISE NOTICE '-> cron_process_windy_fn for [%]', windy_rec;
+        PERFORM set_config('vessel.id', windy_rec.vessel_id, false);
+        --RAISE WARNING 'public.cron_process_windy_rec_fn() scheduler vessel.id %, user.id', current_setting('vessel.id', false), current_setting('user.id', false);
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(windy_rec.vessel_id::TEXT);
+        RAISE NOTICE '-> cron_process_windy_fn checking user_settings [%]', user_settings;
+        -- Get all metrics from the last windy_last_metric avg by 5 minutes
+        -- TODO json_agg to send all data in once, but issue with py jsonb transformation decimal.
+        FOR metric_rec in
+            SELECT time_bucket('5 minutes', m.time) AS time_bucket,
+                    avg((m.metrics->'environment.outside.temperature')::numeric) AS temperature,
+                    avg((m.metrics->'environment.outside.pressure')::numeric) AS pressure,
+                    avg((m.metrics->'environment.outside.relativeHumidity')::numeric) AS rh,
+                    avg((m.metrics->'environment.wind.directionTrue')::numeric) AS winddir,
+                    avg((m.metrics->'environment.wind.speedTrue')::numeric) AS wind,
+                    max((m.metrics->'environment.wind.speedTrue')::numeric) AS gust,
+                    last(latitude, time) AS lat,
+                    last(longitude, time) AS lng
+                FROM api.metrics m
+                WHERE vessel_id = windy_rec.vessel_id
+                    AND m.time >= windy_rec.last_metric::TIMESTAMPTZ
+                GROUP BY time_bucket
+                ORDER BY time_bucket ASC LIMIT 100
+        LOOP
+            RAISE NOTICE '-> cron_process_windy_fn checking metrics [%]', metric_rec;
+            IF metric_rec.wind is null or metric_rec.temperature is null THEN
+                -- Ignore when there is no metrics.
+                -- Send notification
+                PERFORM send_notification_fn('windy_error'::TEXT, user_settings::JSONB);
+                -- Disable windy
+                PERFORM api.update_user_preferences_fn('{public_windy}'::TEXT, 'false'::TEXT);
+                RETURN;
+            END IF;
+            -- https://community.windy.com/topic/8168/report-your-weather-station-data-to-windy
+            -- temp from kelvin to celcuis
+            -- winddir from radiant to degres
+            -- rh from ratio to percentage
+            SELECT jsonb_build_object(
+                'dateutc', metric_rec.time_bucket,
+                'station', windy_rec.id,
+                'name', windy_rec.name,
+                'lat', metric_rec.lat,
+                'lon', metric_rec.lng,
+                'wind', metric_rec.wind,
+                'gust', metric_rec.gust,
+                'pressure', metric_rec.pressure,
+                'winddir', radiantToDegrees(metric_rec.winddir::numeric),
+                'temp', kelvinToCel(metric_rec.temperature::numeric),
+                'rh', valToPercent(metric_rec.rh::numeric)
+                ) INTO windy_metric;
+            RAISE NOTICE '-> cron_process_windy_fn checking windy_metrics [%]', windy_metric;
+            SELECT windy_pws_py_fn(windy_metric, user_settings, app_settings) into windy_pws;
+            RAISE NOTICE '-> cron_process_windy_fn Windy PWS [%]', ((windy_pws->'header')::JSONB ? 'id');
+            IF NOT((user_settings->'settings')::JSONB ? 'windy') and ((windy_pws->'header')::JSONB ? 'id') then
+                RAISE NOTICE '-> cron_process_windy_fn new Windy PWS [%]', (windy_pws->'header')::JSONB->>'id';
+                -- Send metrics to Windy
+                PERFORM api.update_user_preferences_fn('{windy}'::TEXT, ((windy_pws->'header')::JSONB->>'id')::TEXT);
+                -- Send notification
+                PERFORM send_notification_fn('windy'::TEXT, user_settings::JSONB);
+                -- Refresh user settings after first success
+                user_settings := get_user_settings_from_vesselid_fn(windy_rec.vessel_id::TEXT);
+            END IF;
+            -- Record last metrics time
+            SELECT metric_rec.time_bucket INTO last_metric;
+        END LOOP;
+        PERFORM api.update_user_preferences_fn('{windy_last_metric}'::TEXT, last_metric::TEXT);
+    END LOOP;
+END;
+$$ language plpgsql;
+
+DROP FUNCTION public.delete_vessel_fn;
+CREATE OR REPLACE FUNCTION public.delete_vessel_fn(IN _vessel_id TEXT) RETURNS JSONB
+AS $delete_vessel$
+DECLARE
+  total_metrics INTEGER;
+  del_metrics INTEGER;
+  del_logs INTEGER;
+  del_stays INTEGER;
+  del_moorages INTEGER;
+  del_queue INTEGER;
+  out_json JSONB;
+BEGIN
+    select count(*) INTO total_metrics from api.metrics m where vessel_id = _vessel_id;
+    WITH deleted AS (delete from api.metrics m where vessel_id = _vessel_id RETURNING *) SELECT count(*) INTO del_metrics FROM deleted;
+    WITH deleted AS (delete from api.logbook l where vessel_id = _vessel_id RETURNING *) SELECT count(*) INTO del_logs FROM deleted;
+    WITH deleted AS (delete from api.stays s where vessel_id = _vessel_id RETURNING *) SELECT count(*) INTO del_stays FROM deleted;
+    WITH deleted AS (delete from api.moorages m where vessel_id = _vessel_id RETURNING *) SELECT count(*) INTO del_moorages FROM deleted;
+    WITH deleted AS (delete from public.process_queue m where ref_id = _vessel_id RETURNING *) SELECT count(*) INTO del_queue FROM deleted;
+    SELECT jsonb_build_object('total_metrics', total_metrics,
+                            'del_metrics', del_metrics,
+                            'del_logs', del_logs,
+                            'del_stays', del_stays,
+                            'del_moorages', del_moorages,
+                            'del_queue', del_queue) INTO out_json;
+    RETURN out_json;
+END
+$delete_vessel$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.delete_vessel_fn
+    IS 'Delete all vessel data (metrics,logbook,stays,moorages,process_queue) for a vessel_id';
+
+DROP FUNCTION IF EXISTS public.cron_process_no_activity_fn();
+CREATE OR REPLACE FUNCTION public.cron_process_no_activity_fn() RETURNS void AS $no_activity$
+DECLARE
+    no_activity_rec record;
+    user_settings jsonb;
+    total_metrics INTEGER;
+    total_logs INTEGER;
+    del_metrics INTEGER;
+    out_json JSONB;
+BEGIN
+    -- Check for vessel with no activity for more than 230 days
+    RAISE NOTICE 'cron_process_no_activity_fn';
+    FOR no_activity_rec in
+        SELECT
+            v.owner_email,m.name,m.vessel_id,m.time,a.first
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels v ON v.owner_email = a.email
+            LEFT JOIN api.metadata m ON v.vessel_id = m.vessel_id
+            WHERE m.time < NOW() AT TIME ZONE 'UTC' - INTERVAL '230 DAYS'
+                AND v.owner_email <> 'demo@openplotter.cloud'
+            ORDER BY m.time DESC
+    LOOP
+        RAISE NOTICE '-> cron_process_no_activity_rec_fn for [%]', no_activity_rec;
+        SELECT json_build_object('email', no_activity_rec.owner_email, 'recipient', no_activity_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_no_activity_rec_fn [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('no_activity'::TEXT, user_settings::JSONB);
+        SELECT count(*) INTO total_metrics from api.metrics where vessel_id = no_activity_rec.vessel_id;
+        WITH deleted AS (delete from api.metrics m where vessel_id = no_activity_rec.vessel_id RETURNING *) SELECT count(*) INTO del_metrics FROM deleted;
+        SELECT count(*) INTO total_logs from api.logbook where vessel_id = no_activity_rec.vessel_id;
+        SELECT jsonb_build_object('total_metrics', total_metrics, 'total_logs', total_logs, 'del_metrics', del_metrics) INTO out_json;
+        RAISE NOTICE '-> debug cron_process_no_activity_rec_fn [%]', out_json;
+    END LOOP;
+END;
+$no_activity$ language plpgsql;
+
+DROP FUNCTION public.delete_account_fn(text,text);
+CREATE OR REPLACE FUNCTION public.delete_account_fn(IN _email TEXT, IN _vessel_id TEXT) RETURNS JSONB
+AS $delete_account$
+DECLARE
+    del_vessel_data JSONB;
+    del_meta INTEGER;
+    del_vessel INTEGER;
+    del_account INTEGER;
+    out_json JSONB;
+BEGIN
+    SELECT public.delete_vessel_fn(_vessel_id) INTO del_vessel_data;
+    WITH deleted AS (delete from api.metadata where vessel_id = _vessel_id RETURNING *) SELECT count(*) INTO del_meta FROM deleted;
+    WITH deleted AS (delete from auth.vessels where vessel_id = _vessel_id RETURNING *) SELECT count(*) INTO del_vessel FROM deleted;
+    WITH deleted AS (delete from auth.accounts where email = _email RETURNING *) SELECT count(*) INTO del_account FROM deleted;
+    SELECT jsonb_build_object('del_metadata', del_meta,
+                            'del_vessel', del_vessel,
+                            'del_account', del_account) || del_vessel_data INTO out_json;
+    RETURN out_json;
+END
+$delete_account$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.delete_account_fn
+    IS 'Delete all data for a account by email and vessel_id';
+
+-- Update version
+UPDATE public.app_settings
+	SET value='0.7.1'
+	WHERE "name"='app.version';

initdb/99_migrations_202404.sql

@@ -0,0 +1,625 @@
+---------------------------------------------------------------------------
+-- Copyright 2021-2024 Francois Lacroix <xbgmsharp@gmail.com>
+-- This file is part of PostgSail which is released under Apache License, Version 2.0 (the "License").
+-- See file LICENSE or go to http://www.apache.org/licenses/LICENSE-2.0 for full license details.
+--
+-- Migration April 2024
+--
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+\echo 'Timing mode is enabled'
+\timing
+
+\echo 'Force timezone, just in case'
+set timezone to 'UTC';
+
+UPDATE public.email_templates
+	SET email_content='Hello __RECIPIENT__,
+Sorry!We could not convert your boat into a Windy Personal Weather Station due to missing data (temperature, wind or pressure).
+Windy Personal Weather Station is now disable.'
+	WHERE "name"='windy_error';
+
+CREATE OR REPLACE FUNCTION public.cron_windy_fn() RETURNS void AS $$
+DECLARE
+    windy_rec record;
+    default_last_metric TIMESTAMPTZ := NOW() - interval '1 day';
+    last_metric TIMESTAMPTZ := NOW();
+    metric_rec record;
+    windy_metric jsonb;
+    app_settings jsonb;
+    user_settings jsonb;
+    windy_pws jsonb;
+BEGIN
+    -- Check for new observations pending update
+    RAISE NOTICE 'cron_process_windy_fn';
+    -- Gather url from app settings
+    app_settings := get_app_settings_fn();
+    -- Find users with Windy active and with an active vessel
+    -- Map account id to Windy Station ID
+    FOR windy_rec in
+        SELECT
+            a.id,a.email,v.vessel_id,v.name,
+            COALESCE((a.preferences->'windy_last_metric')::TEXT, default_last_metric::TEXT) as last_metric
+            FROM auth.accounts a
+            LEFT JOIN auth.vessels AS v ON v.owner_email = a.email
+            LEFT JOIN api.metadata AS m ON m.vessel_id = v.vessel_id
+            WHERE (a.preferences->'public_windy')::boolean = True
+                AND m.active = True
+    LOOP
+        RAISE NOTICE '-> cron_process_windy_fn for [%]', windy_rec;
+        PERFORM set_config('vessel.id', windy_rec.vessel_id, false);
+        --RAISE WARNING 'public.cron_process_windy_rec_fn() scheduler vessel.id %, user.id', current_setting('vessel.id', false), current_setting('user.id', false);
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(windy_rec.vessel_id::TEXT);
+        RAISE NOTICE '-> cron_process_windy_fn checking user_settings [%]', user_settings;
+        -- Get all metrics from the last windy_last_metric avg by 5 minutes
+        -- TODO json_agg to send all data in once, but issue with py jsonb transformation decimal. 
+        FOR metric_rec in
+            SELECT time_bucket('5 minutes', m.time) AS time_bucket,
+                    avg((m.metrics->'environment.outside.temperature')::numeric) AS temperature,
+                    avg((m.metrics->'environment.outside.pressure')::numeric) AS pressure,
+                    avg((m.metrics->'environment.outside.relativeHumidity')::numeric) AS rh,
+                    avg((m.metrics->'environment.wind.directionTrue')::numeric) AS winddir,
+                    avg((m.metrics->'environment.wind.speedTrue')::numeric) AS wind,
+                    max((m.metrics->'environment.wind.speedTrue')::numeric) AS gust,
+                    last(latitude, time) AS lat,
+                    last(longitude, time) AS lng
+                FROM api.metrics m
+                WHERE vessel_id = windy_rec.vessel_id
+                    AND m.time >= windy_rec.last_metric::TIMESTAMPTZ
+                GROUP BY time_bucket
+                ORDER BY time_bucket ASC LIMIT 100
+        LOOP
+            RAISE NOTICE '-> cron_process_windy_fn checking metrics [%]', metric_rec;
+	        if metric_rec.wind is null or metric_rec.temperature is null 
+	        	or metric_rec.pressure is null or metric_rec.rh is null then
+	           -- Ignore when there is no metrics.
+               -- Send notification
+               PERFORM send_notification_fn('windy_error'::TEXT, user_settings::JSONB);
+			   -- Disable windy
+	           PERFORM api.update_user_preferences_fn('{public_windy}'::TEXT, 'false'::TEXT);
+	           RETURN;
+	        end if;
+            -- https://community.windy.com/topic/8168/report-your-weather-station-data-to-windy
+            -- temp from kelvin to Celsius
+            -- winddir from radiant to degrees
+            -- rh from ratio to percentage
+            SELECT jsonb_build_object(
+                'dateutc', metric_rec.time_bucket,
+                'station', windy_rec.id,
+                'name', windy_rec.name,
+                'lat', metric_rec.lat,
+                'lon', metric_rec.lng,
+                'wind', metric_rec.wind,
+                'gust', metric_rec.gust,
+                'pressure', metric_rec.pressure,
+                'winddir', radiantToDegrees(metric_rec.winddir::numeric),
+                'temp', kelvinToCel(metric_rec.temperature::numeric),
+                'rh', valToPercent(metric_rec.rh::numeric)
+                ) INTO windy_metric;
+            RAISE NOTICE '-> cron_process_windy_fn checking windy_metrics [%]', windy_metric;
+            SELECT windy_pws_py_fn(windy_metric, user_settings, app_settings) into windy_pws;
+            RAISE NOTICE '-> cron_process_windy_fn Windy PWS [%]', ((windy_pws->'header')::JSONB ? 'id');
+            IF NOT((user_settings->'settings')::JSONB ? 'windy') and ((windy_pws->'header')::JSONB ? 'id') then
+                RAISE NOTICE '-> cron_process_windy_fn new Windy PWS [%]', (windy_pws->'header')::JSONB->>'id';
+                -- Send metrics to Windy
+                PERFORM api.update_user_preferences_fn('{windy}'::TEXT, ((windy_pws->'header')::JSONB->>'id')::TEXT);
+                -- Send notification
+                PERFORM send_notification_fn('windy'::TEXT, user_settings::JSONB);
+                -- Refresh user settings after first success
+                user_settings := get_user_settings_from_vesselid_fn(windy_rec.vessel_id::TEXT);
+            END IF;
+            -- Record last metrics time
+            SELECT metric_rec.time_bucket INTO last_metric;
+        END LOOP;
+        PERFORM api.update_user_preferences_fn('{windy_last_metric}'::TEXT, last_metric::TEXT);
+    END LOOP;
+END;
+$$ language plpgsql;
+
+-- Add security definer, run this function as admin to avoid weird bug
+-- ERROR:  variable not found in subplan target list
+CREATE OR REPLACE FUNCTION api.delete_logbook_fn(IN _id integer) RETURNS BOOLEAN AS $delete_logbook$
+    DECLARE
+        logbook_rec record;
+        previous_stays_id numeric;
+        current_stays_departed text;
+        current_stays_id numeric;
+        current_stays_active boolean;
+       BEGIN
+        -- If _id is not NULL
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> delete_logbook_fn invalid input %', _id;
+            RETURN FALSE;
+        END IF;
+        -- Get the logbook record with all necessary fields exist
+        SELECT * INTO logbook_rec
+            FROM api.logbook
+            WHERE id = _id;
+        -- Ensure the query is successful
+        IF logbook_rec.vessel_id IS NULL THEN
+            RAISE WARNING '-> delete_logbook_fn invalid logbook %', _id;
+            RETURN FALSE;
+        END IF;
+        -- Update logbook
+        UPDATE api.logbook l
+            SET notes = 'mark for deletion'
+            WHERE l.vessel_id = current_setting('vessel.id', false)
+                AND id = logbook_rec.id;
+        -- Update metrics status to moored
+        -- This generate an error when run as user_role "variable not found in subplan target list"
+        UPDATE api.metrics
+            SET status = 'moored'
+            WHERE time >= logbook_rec._from_time
+                AND time <= logbook_rec._to_time
+                AND vessel_id = current_setting('vessel.id', false);
+        -- Get related stays
+        SELECT id,departed,active INTO current_stays_id,current_stays_departed,current_stays_active
+            FROM api.stays s
+            WHERE s.vessel_id = current_setting('vessel.id', false)
+                AND s.arrived = logbook_rec._to_time;
+        -- Update related stays
+        UPDATE api.stays s
+            SET notes = 'mark for deletion'
+            WHERE s.vessel_id = current_setting('vessel.id', false)
+                AND s.arrived = logbook_rec._to_time;
+        -- Find previous stays
+        SELECT id INTO previous_stays_id
+            FROM api.stays s
+            WHERE s.vessel_id = current_setting('vessel.id', false)
+                AND s.arrived < logbook_rec._to_time
+                ORDER BY s.arrived DESC LIMIT 1;
+        -- Update previous stays with the departed time from current stays
+        --  and set the active state from current stays
+        UPDATE api.stays
+            SET departed = current_stays_departed::TIMESTAMPTZ,
+                active = current_stays_active
+            WHERE vessel_id = current_setting('vessel.id', false)
+                AND id = previous_stays_id;
+        -- Clean up, remove invalid logbook and stay entry
+        DELETE FROM api.logbook WHERE id = logbook_rec.id;
+        RAISE WARNING '-> delete_logbook_fn delete logbook [%]', logbook_rec.id;
+        DELETE FROM api.stays WHERE id = current_stays_id;
+        RAISE WARNING '-> delete_logbook_fn delete stays [%]', current_stays_id;
+        -- Clean up, Subtract (-1) moorages ref count
+        UPDATE api.moorages
+            SET reference_count = reference_count - 1
+            WHERE vessel_id = current_setting('vessel.id', false)
+                AND id = previous_stays_id;
+        RETURN TRUE;
+    END;
+$delete_logbook$ LANGUAGE plpgsql security definer;
+
+-- Allow users to update certain columns on specific TABLES on API schema add reference_count, when deleting a log
+GRANT UPDATE (name, notes, stay_code, home_flag, reference_count) ON api.moorages TO user_role;
+
+-- Allow users to update certain columns on specific TABLES on API schema add track_geojson
+GRANT UPDATE (name, _from, _to, notes, track_geojson) ON api.logbook TO user_role;
+
+DROP FUNCTION IF EXISTS api.timelapse2_fn;
+CREATE OR REPLACE FUNCTION api.timelapse2_fn(
+    IN start_log INTEGER DEFAULT NULL,
+    IN end_log INTEGER DEFAULT NULL,
+    IN start_date TEXT DEFAULT NULL,
+    IN end_date TEXT DEFAULT NULL,
+    OUT geojson JSONB) RETURNS JSONB AS $timelapse2$
+    DECLARE
+        _geojson jsonb;
+    BEGIN
+        -- Using sub query to force id order by time
+        -- User can now directly edit the json to add comment or remove track point
+        -- Merge json track_geojson with Geometry Point into a single GeoJSON Points
+        --raise WARNING 'input % % %' , start_log, end_log, public.isnumeric(end_log::text);
+        IF start_log IS NOT NULL AND end_log IS NULL THEN
+            end_log := start_log;
+        END IF;
+        IF start_date IS NOT NULL AND end_date IS NULL THEN
+            end_date := start_date;
+        END IF;
+        --raise WARNING 'input % % %' , start_log, end_log, public.isnumeric(end_log::text);
+        IF start_log IS NOT NULL AND public.isnumeric(start_log::text) AND public.isnumeric(end_log::text) THEN
+            SELECT jsonb_agg(
+                        jsonb_build_object('type', 'Feature',
+                                            'properties', f->'properties',
+                                            'geometry', jsonb_build_object( 'coordinates', f->'geometry'->'coordinates', 'type', 'Point'))
+                    ) INTO _geojson
+            FROM (
+                SELECT jsonb_array_elements(track_geojson->'features') AS f
+                    FROM api.logbook l
+                    WHERE l.id >= start_log
+                        AND l.id <= end_log
+                        AND l.track_geojson IS NOT NULL
+                    ORDER BY l._from_time ASC
+            ) AS sub
+            WHERE (f->'geometry'->>'type') = 'Point';
+        ELSIF start_date IS NOT NULL AND public.isdate(start_date::text) AND public.isdate(end_date::text) THEN
+            SELECT jsonb_agg(
+                        jsonb_build_object('type', 'Feature',
+                                            'properties', f->'properties',
+                                            'geometry', jsonb_build_object( 'coordinates', f->'geometry'->'coordinates', 'type', 'Point'))
+                    ) INTO _geojson
+            FROM (
+                SELECT jsonb_array_elements(track_geojson->'features') AS f
+                    FROM api.logbook l
+                    WHERE l._from_time >= start_date::TIMESTAMPTZ
+                        AND l._to_time <= end_date::TIMESTAMPTZ + interval '23 hours 59 minutes'
+                        AND l.track_geojson IS NOT NULL
+                    ORDER BY l._from_time ASC
+            ) AS sub
+            WHERE (f->'geometry'->>'type') = 'Point';
+        ELSE
+            SELECT jsonb_agg(
+                        jsonb_build_object('type', 'Feature',
+                                            'properties', f->'properties',
+                                            'geometry', jsonb_build_object( 'coordinates', f->'geometry'->'coordinates', 'type', 'Point'))
+                    ) INTO _geojson
+            FROM (
+                SELECT jsonb_array_elements(track_geojson->'features') AS f
+                    FROM api.logbook l
+                    WHERE l.track_geojson IS NOT NULL
+                    ORDER BY l._from_time ASC
+            ) AS sub
+            WHERE (f->'geometry'->>'type') = 'Point';
+        END IF;
+        -- Return a GeoJSON MultiLineString
+        -- result _geojson [null, null]
+        --RAISE WARNING 'result _geojson %' , _geojson;
+        SELECT jsonb_build_object(
+            'type', 'FeatureCollection',
+            'features', _geojson ) INTO geojson;
+    END;
+$timelapse2$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.timelapse2_fn
+    IS 'Export all selected logs geojson `track_geojson` to a geojson as points including properties';
+
+-- Allow timelapse2_fn execution for user_role and api_anonymous (public replay)
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA api TO user_role;
+GRANT EXECUTE ON FUNCTION api.timelapse2_fn TO api_anonymous;
+
+DROP FUNCTION IF EXISTS public.process_logbook_queue_fn;
+CREATE OR REPLACE FUNCTION public.process_logbook_queue_fn(IN _id integer) RETURNS void AS $process_logbook_queue$
+    DECLARE
+        logbook_rec record;
+        from_name text;
+        to_name text;
+        log_name text;
+        from_moorage record;
+        to_moorage record;
+        avg_rec record;
+        geo_rec record;
+        log_settings jsonb;
+        user_settings jsonb;
+        geojson jsonb;
+        extra_json jsonb;
+        trip_note jsonb;
+        from_moorage_note jsonb;
+        to_moorage_note jsonb;
+    BEGIN
+        -- If _id is not NULL
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> process_logbook_queue_fn invalid input %', _id;
+            RETURN;
+        END IF;
+        -- Get the logbook record with all necessary fields exist
+        SELECT * INTO logbook_rec
+            FROM api.logbook
+            WHERE active IS false
+                AND id = _id
+                AND _from_lng IS NOT NULL
+                AND _from_lat IS NOT NULL
+                AND _to_lng IS NOT NULL
+                AND _to_lat IS NOT NULL;
+        -- Ensure the query is successful
+        IF logbook_rec.vessel_id IS NULL THEN
+            RAISE WARNING '-> process_logbook_queue_fn invalid logbook %', _id;
+            RETURN;
+        END IF;
+
+        PERFORM set_config('vessel.id', logbook_rec.vessel_id, false);
+        --RAISE WARNING 'public.process_logbook_queue_fn() scheduler vessel.id %, user.id', current_setting('vessel.id', false), current_setting('user.id', false);
+
+        -- Calculate logbook data average and geo
+        -- Update logbook entry with the latest metric data and calculate data
+        avg_rec := logbook_update_avg_fn(logbook_rec.id, logbook_rec._from_time::TEXT, logbook_rec._to_time::TEXT);
+        geo_rec := logbook_update_geom_distance_fn(logbook_rec.id, logbook_rec._from_time::TEXT, logbook_rec._to_time::TEXT);
+
+        -- Do we have an existing moorage within 300m of the new log
+        -- generate logbook name, concat _from_location and _to_location from moorage name
+        from_moorage := process_lat_lon_fn(logbook_rec._from_lng::NUMERIC, logbook_rec._from_lat::NUMERIC);
+        to_moorage := process_lat_lon_fn(logbook_rec._to_lng::NUMERIC, logbook_rec._to_lat::NUMERIC);
+        SELECT CONCAT(from_moorage.moorage_name, ' to ' , to_moorage.moorage_name) INTO log_name;
+
+        -- Process `propulsion.*.runTime` and `navigation.log`
+        -- Calculate extra json
+        extra_json := logbook_update_extra_json_fn(logbook_rec.id, logbook_rec._from_time::TEXT, logbook_rec._to_time::TEXT);
+
+        RAISE NOTICE 'Updating valid logbook entry logbook id:[%] start:[%] end:[%]', logbook_rec.id, logbook_rec._from_time, logbook_rec._to_time;
+        UPDATE api.logbook
+            SET
+                duration = (logbook_rec._to_time::TIMESTAMPTZ - logbook_rec._from_time::TIMESTAMPTZ),
+                avg_speed = avg_rec.avg_speed,
+                max_speed = avg_rec.max_speed,
+                max_wind_speed = avg_rec.max_wind_speed,
+                _from = from_moorage.moorage_name,
+                _from_moorage_id = from_moorage.moorage_id,
+                _to_moorage_id = to_moorage.moorage_id,
+                _to = to_moorage.moorage_name,
+                name = log_name,
+                track_geom = geo_rec._track_geom,
+                distance = geo_rec._track_distance,
+                extra = extra_json,
+                notes = NULL -- reset pre_log process
+            WHERE id = logbook_rec.id;
+
+        -- GeoJSON require track_geom field
+        geojson := logbook_update_geojson_fn(logbook_rec.id, logbook_rec._from_time::TEXT, logbook_rec._to_time::TEXT);
+        UPDATE api.logbook
+            SET
+                track_geojson = geojson
+            WHERE id = logbook_rec.id;
+
+        -- Add trip details  name as note for the first geometry point entry from the GeoJSON
+        SELECT format('{"trip": { "name": "%s", "duration": "%s", "distance": "%s" }}', logbook_rec.name, logbook_rec.duration, logbook_rec.distance) into trip_note;
+	    -- Update the properties of the first feature
+        UPDATE api.logbook
+            SET track_geojson = jsonb_set(
+                track_geojson,
+                '{features, 1, properties}',
+                (track_geojson -> 'features' -> 1 -> 'properties' || trip_note)::jsonb
+            )
+            WHERE id = logbook_rec.id
+                and track_geojson -> 'features' -> 1 -> 'geometry' ->> 'type' = 'Point';
+
+        -- Add moorage name as note for the third and last entry of the GeoJSON
+        SELECT format('{"notes": "%s"}', from_moorage.moorage_name) into from_moorage_note;
+        -- Update the properties of the third feature, the second with geometry point
+        UPDATE api.logbook
+            SET track_geojson = jsonb_set(
+                track_geojson,
+                '{features, 2, properties}',
+                (track_geojson -> 'features' -> 2 -> 'properties' || from_moorage_note)::jsonb
+            )
+            WHERE id = logbook_rec.id
+                AND track_geojson -> 'features' -> 2 -> 'geometry' ->> 'type' = 'Point';
+
+        -- Update the note properties of the last feature with geometry point
+        SELECT format('{"notes": "%s"}', to_moorage.moorage_name) into to_moorage_note;
+        UPDATE api.logbook
+            SET track_geojson = jsonb_set(
+                track_geojson,
+                '{features, -1, properties}',
+                CASE
+                    WHEN COALESCE((track_geojson -> 'features' -> -1 -> 'properties' ->> 'notes'), '') = '' THEN
+                        (track_geojson -> 'features' -> -1 -> 'properties' || to_moorage_note)::jsonb
+                    ELSE
+                        track_geojson -> 'features' -> -1 -> 'properties'
+                END
+            )
+            WHERE id = logbook_rec.id
+                AND track_geojson -> 'features' -> -1 -> 'geometry' ->> 'type' = 'Point';
+
+        -- Prepare notification, gather user settings
+        SELECT json_build_object('logbook_name', log_name, 'logbook_link', logbook_rec.id) into log_settings;
+        user_settings := get_user_settings_from_vesselid_fn(logbook_rec.vessel_id::TEXT);
+        SELECT user_settings::JSONB || log_settings::JSONB into user_settings;
+        RAISE NOTICE '-> debug process_logbook_queue_fn get_user_settings_from_vesselid_fn [%]', user_settings;
+        RAISE NOTICE '-> debug process_logbook_queue_fn log_settings [%]', log_settings;
+        -- Send notification
+        PERFORM send_notification_fn('logbook'::TEXT, user_settings::JSONB);
+        -- Process badges
+        RAISE NOTICE '-> debug process_logbook_queue_fn user_settings [%]', user_settings->>'email'::TEXT;
+        PERFORM set_config('user.email', user_settings->>'email'::TEXT, false);
+        PERFORM badges_logbook_fn(logbook_rec.id, logbook_rec._to_time::TEXT);
+        PERFORM badges_geom_fn(logbook_rec.id, logbook_rec._to_time::TEXT);
+    END;
+$process_logbook_queue$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.process_logbook_queue_fn
+    IS 'Update logbook details when completed, logbook_update_avg_fn, logbook_update_geom_distance_fn, reverse_geocode_py_fn';
+
+-- Update the pre.check for the new timelapse function
+CREATE OR REPLACE FUNCTION public.check_jwt() RETURNS void AS $$
+-- Prevent unregister user or unregister vessel access
+-- Allow anonymous access
+-- Need to be refactor and simplify, specially the anonymous part.
+DECLARE
+  _role name;
+  _email text;
+  anonymous record;
+  _path name;
+  _vid text;
+  _vname text;
+  boat TEXT;
+  _pid INTEGER := 0; -- public_id
+  _pvessel TEXT := NULL; -- public_type
+  _ptype TEXT := NULL; -- public_type
+  _ppath BOOLEAN := False; -- public_path
+  _pvalid BOOLEAN := False; -- public_valid
+  _pheader text := NULL; -- public_header
+  valid_public_type BOOLEAN := False;
+  account_rec record;
+  vessel_rec record;
+BEGIN
+  -- Extract email and role from jwt token
+  --RAISE WARNING 'check_jwt jwt %', current_setting('request.jwt.claims', true);
+  SELECT current_setting('request.jwt.claims', true)::json->>'email' INTO _email;
+  PERFORM set_config('user.email', _email, false);
+  SELECT current_setting('request.jwt.claims', true)::json->>'role' INTO _role;
+  --RAISE WARNING 'jwt email %', current_setting('request.jwt.claims', true)::json->>'email';
+  --RAISE WARNING 'jwt role %', current_setting('request.jwt.claims', true)::json->>'role';
+  --RAISE WARNING 'cur_user %', current_user;
+
+  --TODO SELECT current_setting('request.jwt.uid', true)::json->>'uid' INTO _user_id;
+  --TODO RAISE WARNING 'jwt user_id %', current_setting('request.jwt.uid', true)::json->>'uid';
+  --TODO SELECT current_setting('request.jwt.vid', true)::json->>'vid' INTO _vessel_id;
+  --TODO RAISE WARNING 'jwt vessel_id %', current_setting('request.jwt.vid', true)::json->>'vid';
+  IF _role = 'user_role' THEN
+    -- Check the user exist in the accounts table
+    SELECT * INTO account_rec
+        FROM auth.accounts
+        WHERE auth.accounts.email = _email;
+    IF account_rec.email IS NULL THEN
+        RAISE EXCEPTION 'Invalid user'
+            USING HINT = 'Unknown user or password';
+    END IF;
+    -- Set session variables
+    PERFORM set_config('user.id', account_rec.user_id, false);
+    SELECT current_setting('request.path', true) into _path;
+    --RAISE WARNING 'req path %', current_setting('request.path', true);
+    -- Function allow without defined vessel like for anonymous role
+    IF _path ~ '^\/rpc\/(login|signup|recover|reset)$' THEN
+        RETURN;
+    END IF;
+    -- Function allow without defined vessel as user role
+    -- openapi doc, user settings, otp code and vessel registration
+    IF _path = '/rpc/settings_fn'
+        OR _path = '/rpc/register_vessel'
+        OR _path = '/rpc/update_user_preferences_fn'
+        OR _path = '/rpc/versions_fn'
+        OR _path = '/rpc/email_fn'
+        OR _path = '/' THEN
+        RETURN;
+    END IF;
+    -- Check a vessel and user exist
+    SELECT auth.vessels.* INTO vessel_rec
+        FROM auth.vessels, auth.accounts
+        WHERE auth.vessels.owner_email = auth.accounts.email
+            AND auth.accounts.email = _email;
+    -- check if boat exist yet?
+    IF vessel_rec.owner_email IS NULL THEN
+        -- Return http status code 551 with message
+        RAISE sqlstate 'PT551' using
+            message = 'Vessel Required',
+            detail = 'Invalid vessel',
+            hint = 'Unknown vessel';
+        --RETURN; -- ignore if not exist
+    END IF;
+    -- Redundant?
+    IF vessel_rec.vessel_id IS NULL THEN
+        RAISE EXCEPTION 'Invalid vessel'
+            USING HINT = 'Unknown vessel id';
+    END IF;
+    -- Set session variables
+    PERFORM set_config('vessel.id', vessel_rec.vessel_id, false);
+    PERFORM set_config('vessel.name', vessel_rec.name, false);
+    --RAISE WARNING 'public.check_jwt() user_role vessel.id [%]', current_setting('vessel.id', false);
+    --RAISE WARNING 'public.check_jwt() user_role vessel.name [%]', current_setting('vessel.name', false);
+  ELSIF _role = 'vessel_role' THEN
+    SELECT current_setting('request.path', true) into _path;
+    --RAISE WARNING 'req path %', current_setting('request.path', true);
+    -- Function allow without defined vessel like for anonymous role
+    IF _path ~ '^\/rpc\/(oauth_\w+)$' THEN
+        RETURN;
+    END IF;
+    -- Extract vessel_id from jwt token
+    SELECT current_setting('request.jwt.claims', true)::json->>'vid' INTO _vid;
+    -- Check the vessel and user exist
+    SELECT auth.vessels.* INTO vessel_rec
+        FROM auth.vessels, auth.accounts
+        WHERE auth.vessels.owner_email = auth.accounts.email
+            AND auth.accounts.email = _email
+            AND auth.vessels.vessel_id = _vid;
+    IF vessel_rec.owner_email IS NULL THEN
+        RAISE EXCEPTION 'Invalid vessel'
+            USING HINT = 'Unknown vessel owner_email';
+    END IF;
+    PERFORM set_config('vessel.id', vessel_rec.vessel_id, false);
+    PERFORM set_config('vessel.name', vessel_rec.name, false);
+    --RAISE WARNING 'public.check_jwt() user_role vessel.name %', current_setting('vessel.name', false);
+    --RAISE WARNING 'public.check_jwt() user_role vessel.id %', current_setting('vessel.id', false);
+  ELSIF _role = 'api_anonymous' THEN
+    --RAISE WARNING 'public.check_jwt() api_anonymous';
+    -- Check if path is a valid allow anonymous path
+    SELECT current_setting('request.path', true) ~ '^/(logs_view|log_view|rpc/timelapse_fn|rpc/timelapse2_fn|monitoring_view|stats_logs_view|stats_moorages_view|rpc/stats_logs_fn)$' INTO _ppath;
+    if _ppath is True then
+        -- Check is custom header is present and valid
+        SELECT current_setting('request.headers', true)::json->>'x-is-public' into _pheader;
+        RAISE WARNING 'public.check_jwt() api_anonymous _pheader [%]', _pheader;
+        if _pheader is null then
+            RAISE EXCEPTION 'Invalid public_header'
+                USING HINT = 'Stop being so evil and maybe you can log in';
+        end if;
+        SELECT convert_from(decode(_pheader, 'base64'), 'utf-8')
+                            ~ '\w+,public_(logs|logs_list|stats|timelapse|monitoring),\d+$' into _pvalid;
+        RAISE WARNING 'public.check_jwt() api_anonymous _pvalid [%]', _pvalid;
+        if _pvalid is null or _pvalid is False then
+            RAISE EXCEPTION 'Invalid public_valid'
+                USING HINT = 'Stop being so evil and maybe you can log in';
+        end if;
+        WITH regex AS (
+            SELECT regexp_match(
+                        convert_from(
+                            decode(_pheader, 'base64'), 'utf-8'),
+                        '(\w+),(public_(logs|logs_list|stats|timelapse|monitoring)),(\d+)$') AS match
+            )
+        SELECT match[1], match[2], match[4] into _pvessel, _ptype, _pid
+            FROM regex;
+        RAISE WARNING 'public.check_jwt() api_anonymous [%] [%] [%]', _pvessel, _ptype, _pid;
+        if _pvessel is not null and _ptype is not null then
+            -- Everything seem fine, get the vessel_id base on the vessel name.
+            SELECT _ptype::name = any(enum_range(null::public_type)::name[]) INTO valid_public_type;
+            IF valid_public_type IS False THEN
+                -- Ignore entry if type is invalid
+                RAISE EXCEPTION 'Invalid public_type'
+                    USING HINT = 'Stop being so evil and maybe you can log in';
+            END IF;
+            -- Check if boat name match public_vessel name
+            boat := '^' || _pvessel || '$';
+            IF _ptype ~ '^public_(logs|timelapse)$' AND _pid > 0 THEN
+                WITH log as (
+                    SELECT vessel_id from api.logbook l where l.id = _pid
+                )
+                SELECT v.vessel_id, v.name into anonymous
+                    FROM auth.accounts a, auth.vessels v, jsonb_each_text(a.preferences) as prefs, log l
+                    WHERE v.vessel_id = l.vessel_id
+                        AND a.email = v.owner_email
+                        AND a.preferences->>'public_vessel'::text ~* boat
+                        AND prefs.key = _ptype::TEXT
+                        AND prefs.value::BOOLEAN = true;
+                RAISE WARNING '-> ispublic_fn public_logs output boat:[%], type:[%], result:[%]', _pvessel, _ptype, anonymous;
+                IF anonymous.vessel_id IS NOT NULL THEN
+                    PERFORM set_config('vessel.id', anonymous.vessel_id, false);
+                    PERFORM set_config('vessel.name', anonymous.name, false);
+                    RETURN;
+                END IF;
+            ELSE
+                SELECT v.vessel_id, v.name into anonymous
+                        FROM auth.accounts a, auth.vessels v, jsonb_each_text(a.preferences) as prefs
+                        WHERE a.email = v.owner_email
+                            AND a.preferences->>'public_vessel'::text ~* boat
+                            AND prefs.key = _ptype::TEXT
+                            AND prefs.value::BOOLEAN = true;
+                RAISE WARNING '-> ispublic_fn output boat:[%], type:[%], result:[%]', _pvessel, _ptype, anonymous;
+                IF anonymous.vessel_id IS NOT NULL THEN
+                    PERFORM set_config('vessel.id', anonymous.vessel_id, false);
+                    PERFORM set_config('vessel.name', anonymous.name, false);
+                    RETURN;
+                END IF;
+            END IF;
+            RAISE sqlstate 'PT404' using message = 'unknown resource';
+        END IF; -- end anonymous path
+    END IF;
+  ELSIF _role <> 'api_anonymous' THEN
+    RAISE EXCEPTION 'Invalid role'
+      USING HINT = 'Stop being so evil and maybe you can log in';
+  END IF;
+END
+$$ language plpgsql security definer;
+-- Description
+COMMENT ON FUNCTION
+    public.check_jwt
+    IS 'PostgREST API db-pre-request check, set_config according to role (api_anonymous,vessel_role,user_role)';
+
+GRANT EXECUTE ON FUNCTION public.check_jwt() TO api_anonymous;
+
+-- Update version
+UPDATE public.app_settings
+	SET value='0.7.2'
+	WHERE "name"='app.version';

initdb/99_migrations_202405.sql

@@ -0,0 +1,784 @@
+---------------------------------------------------------------------------
+-- Copyright 2021-2024 Francois Lacroix <xbgmsharp@gmail.com>
+-- This file is part of PostgSail which is released under Apache License, Version 2.0 (the "License").
+-- See file LICENSE or go to http://www.apache.org/licenses/LICENSE-2.0 for full license details.
+--
+-- Migration May 2024
+--
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+\echo 'Timing mode is enabled'
+\timing
+
+\echo 'Force timezone, just in case'
+set timezone to 'UTC';
+
+INSERT INTO public.email_templates ("name",email_subject,email_content,pushover_title,pushover_message)
+	VALUES ('account_disable','PostgSail Account disable',E'Hello __RECIPIENT__,\nSorry!Your account is disable. Please contact me to solve the issue.','PostgSail Account disable!',E'Sorry!\nYour account is disable. Please contact me to solve the issue.');
+
+-- Check if user is disable due to abuse
+-- Track IP per user to avoid abuse
+create or replace function
+api.login(in email text, in pass text) returns auth.jwt_token as $$
+declare
+  _role name;
+  result auth.jwt_token;
+  app_jwt_secret text;
+  _email_valid boolean := false;
+  _email text := email;
+  _user_id text := null;
+  _user_disable boolean := false;
+  headers   json := current_setting('request.headers', true)::json;
+  client_ip text := coalesce(headers->>'x-client-ip', NULL);
+begin
+  -- check email and password
+  select auth.user_role(email, pass) into _role;
+  if _role is null then
+    -- HTTP/403
+    --raise invalid_password using message = 'invalid user or password';
+    -- HTTP/401
+    raise insufficient_privilege using message = 'invalid user or password';
+  end if;
+
+  -- Check if user is disable due to abuse
+  SELECT preferences['disable'],user_id INTO _user_disable,_user_id
+              FROM auth.accounts a
+              WHERE a.email = _email;
+  IF _user_disable is True then
+  	-- due to the raise, the insert is never committed.
+    --INSERT INTO process_queue (channel, payload, stored, ref_id)
+    --  VALUES ('account_disable', _email, now(), _user_id);
+    RAISE sqlstate 'PT402' using message = 'Account disable, contact us',
+            detail = 'Quota exceeded',
+            hint = 'Upgrade your plan';
+  END IF;
+
+  -- Check email_valid and generate OTP
+  SELECT preferences['email_valid'],user_id INTO _email_valid,_user_id
+              FROM auth.accounts a
+              WHERE a.email = _email;
+  IF _email_valid is null or _email_valid is False THEN
+    INSERT INTO process_queue (channel, payload, stored, ref_id)
+      VALUES ('email_otp', _email, now(), _user_id);
+  END IF;
+
+  -- Track IP per user to avoid abuse
+  --RAISE WARNING 'api.login debug: [%],[%]', client_ip, login.email;
+  IF client_ip IS NOT NULL THEN
+    UPDATE auth.accounts a SET preferences = jsonb_recursive_merge(a.preferences, jsonb_build_object('ip', client_ip)) WHERE a.email = login.email;
+  END IF;
+
+  -- Get app_jwt_secret
+  SELECT value INTO app_jwt_secret
+    FROM app_settings
+    WHERE name = 'app.jwt_secret';
+
+  --RAISE WARNING 'api.login debug: [%],[%],[%]', app_jwt_secret, _role, login.email;
+  -- Generate jwt
+  select jwt.sign(
+  --    row_to_json(r), ''
+  --    row_to_json(r)::json, current_setting('app.jwt_secret')::text
+      row_to_json(r)::json, app_jwt_secret
+    ) as token
+    from (
+      select _role as role, login.email as email,  -- TODO replace with user_id
+    --  select _role as role, user_id as uid, -- add support in check_jwt
+         extract(epoch from now())::integer + 60*60 as exp
+    ) r
+    into result;
+  return result;
+end;
+$$ language plpgsql security definer;
+
+-- Add moorage name to view
+DROP VIEW IF EXISTS api.moorages_stays_view;
+CREATE OR REPLACE VIEW api.moorages_stays_view WITH (security_invoker=true,security_barrier=true) AS
+    select
+        _to.name AS _to_name,
+        _to.id AS _to_id,
+        _to._to_time,
+        _from.id AS _from_id,
+        _from.name AS _from_name,
+        _from._from_time,
+        s.stay_code,s.duration,m.id,m.name
+        FROM api.stays_at sa, api.moorages m, api.stays s
+        LEFT JOIN api.logbook AS _from ON _from._from_time = s.departed
+        LEFT JOIN api.logbook AS _to ON _to._to_time = s.arrived
+        WHERE s.departed IS NOT NULL
+            AND s.name IS NOT NULL
+            AND s.stay_code = sa.stay_code
+            AND s.moorage_id = m.id
+        ORDER BY _to._to_time DESC;
+-- Description
+COMMENT ON VIEW
+    api.moorages_stays_view
+    IS 'Moorages stay listing web view';
+
+-- Create a merge_logbook_fn
+CREATE OR REPLACE FUNCTION api.merge_logbook_fn(IN id_start integer, IN id_end integer) RETURNS void AS $merge_logbook$
+    DECLARE
+        logbook_rec_start record;
+        logbook_rec_end record;
+        log_name text;
+        avg_rec record;
+        geo_rec record;
+        geojson jsonb;
+        extra_json jsonb;
+    BEGIN
+        -- If id_start or id_end is not NULL
+        IF (id_start IS NULL OR id_start < 1) OR (id_end IS NULL OR id_end < 1) THEN
+            RAISE WARNING '-> merge_logbook_fn invalid input % %', id_start, id_end;
+            RETURN;
+        END IF;
+        -- If id_end is lower than id_start
+        IF id_end <= id_start THEN
+            RAISE WARNING '-> merge_logbook_fn invalid input % < %', id_end, id_start;
+            RETURN;
+        END IF;
+        -- Get the start logbook record with all necessary fields exist
+        SELECT * INTO logbook_rec_start
+            FROM api.logbook
+            WHERE active IS false
+                AND id = id_start
+                AND _from_lng IS NOT NULL
+                AND _from_lat IS NOT NULL
+                AND _to_lng IS NOT NULL
+                AND _to_lat IS NOT NULL;
+        -- Ensure the query is successful
+        IF logbook_rec_start.vessel_id IS NULL THEN
+            RAISE WARNING '-> merge_logbook_fn invalid logbook %', id_start;
+            RETURN;
+        END IF;
+        -- Get the end logbook record with all necessary fields exist
+        SELECT * INTO logbook_rec_end
+            FROM api.logbook
+            WHERE active IS false
+                AND id = id_end
+                AND _from_lng IS NOT NULL
+                AND _from_lat IS NOT NULL
+                AND _to_lng IS NOT NULL
+                AND _to_lat IS NOT NULL;
+        -- Ensure the query is successful
+        IF logbook_rec_end.vessel_id IS NULL THEN
+            RAISE WARNING '-> merge_logbook_fn invalid logbook %', id_end;
+            RETURN;
+        END IF;
+
+       	RAISE WARNING '-> merge_logbook_fn logbook start:% end:%', id_start, id_end;
+        PERFORM set_config('vessel.id', logbook_rec_start.vessel_id, false);
+   
+        -- Calculate logbook data average and geo
+        -- Update logbook entry with the latest metric data and calculate data
+        avg_rec := logbook_update_avg_fn(logbook_rec_start.id, logbook_rec_start._from_time::TEXT, logbook_rec_end._to_time::TEXT);
+        geo_rec := logbook_update_geom_distance_fn(logbook_rec_start.id, logbook_rec_start._from_time::TEXT, logbook_rec_end._to_time::TEXT);
+
+	    -- Process `propulsion.*.runTime` and `navigation.log`
+        -- Calculate extra json
+        extra_json := logbook_update_extra_json_fn(logbook_rec_start.id, logbook_rec_start._from_time::TEXT, logbook_rec_end._to_time::TEXT);
+        -- add the avg_wind_speed
+        extra_json := extra_json || jsonb_build_object('avg_wind_speed', avg_rec.avg_wind_speed);
+
+       	-- generate logbook name, concat _from_location and _to_location from moorage name
+       	SELECT CONCAT(logbook_rec_start._from, ' to ', logbook_rec_end._to) INTO log_name;
+        RAISE NOTICE 'Updating valid logbook entry logbook id:[%] start:[%] end:[%]', logbook_rec_start.id, logbook_rec_start._from_time, logbook_rec_end._to_time;
+        UPDATE api.logbook
+            SET
+                -- Update the start logbook with the new calculate metrics
+            	duration = (logbook_rec_end._to_time::TIMESTAMPTZ - logbook_rec_start._from_time::TIMESTAMPTZ),
+                avg_speed = avg_rec.avg_speed,
+                max_speed = avg_rec.max_speed,
+                max_wind_speed = avg_rec.max_wind_speed,
+                name = log_name,
+                track_geom = geo_rec._track_geom,
+                distance = geo_rec._track_distance,
+                extra = extra_json,
+                -- Set _to metrics from end logbook
+                _to = logbook_rec_end._to,
+                _to_moorage_id = logbook_rec_end._to_moorage_id,
+                _to_lat = logbook_rec_end._to_lat,
+                _to_lng = logbook_rec_end._to_lng,
+                _to_time = logbook_rec_end._to_time
+            WHERE id = logbook_rec_start.id;
+
+        -- GeoJSON require track_geom field
+        geojson := logbook_update_geojson_fn(logbook_rec_start.id, logbook_rec_start._from_time::TEXT, logbook_rec_end._to_time::TEXT);
+        UPDATE api.logbook
+            SET
+                track_geojson = geojson
+            WHERE id = logbook_rec_start.id;
+ 
+        -- Update logbook mark for deletion
+        UPDATE api.logbook
+            SET notes = 'mark for deletion'
+            WHERE id = logbook_rec_end.id;
+        -- Update related stays mark for deletion
+        UPDATE api.stays
+            SET notes = 'mark for deletion'
+            WHERE arrived = logbook_rec_start._to_time;
+       -- Update related moorages mark for deletion
+        UPDATE api.moorages
+            SET notes = 'mark for deletion'
+            WHERE id = logbook_rec_start._to_moorage_id;
+
+        -- Clean up, remove invalid logbook and stay, moorage entry
+        DELETE FROM api.logbook WHERE id = logbook_rec_end.id;
+        RAISE WARNING '-> merge_logbook_fn delete logbook id [%]', logbook_rec_end.id;
+        DELETE FROM api.stays WHERE arrived = logbook_rec_start._to_time;
+        RAISE WARNING '-> merge_logbook_fn delete stay arrived [%]', logbook_rec_start._to_time;
+        DELETE FROM api.moorages WHERE id = logbook_rec_start._to_moorage_id;
+        RAISE WARNING '-> merge_logbook_fn delete moorage id [%]', logbook_rec_start._to_moorage_id;
+    END;
+$merge_logbook$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    api.merge_logbook_fn
+    IS 'Merge 2 logbook by id, from the start of the lower log id and the end of the higher log id, update the calculate data as well (avg, geojson)';
+
+-- Add tags to view
+DROP VIEW IF EXISTS api.logs_view;
+CREATE OR REPLACE VIEW api.logs_view
+WITH(security_invoker=true,security_barrier=true)
+AS SELECT id,
+    name,
+    _from AS "from",
+    _from_time AS started,
+    _to AS "to",
+    _to_time AS ended,
+    distance,
+    duration,
+    _from_moorage_id,
+    _to_moorage_id,
+    extra->'tags' AS tags
+   FROM api.logbook l
+  WHERE name IS NOT NULL AND _to_time IS NOT NULL
+  ORDER BY _from_time DESC;
+-- Description
+COMMENT ON VIEW api.logs_view IS 'Logs web view';
+
+-- Update a logbook with avg wind speed
+DROP FUNCTION IF EXISTS public.logbook_update_avg_fn;
+CREATE OR REPLACE FUNCTION public.logbook_update_avg_fn(
+    IN _id integer, 
+    IN _start TEXT, 
+    IN _end TEXT,
+    OUT avg_speed double precision,
+    OUT max_speed double precision,
+    OUT max_wind_speed double precision,
+    OUT avg_wind_speed double precision,
+    OUT count_metric integer
+) AS $logbook_update_avg$
+    BEGIN
+        RAISE NOTICE '-> logbook_update_avg_fn calculate avg for logbook id=%, start:"%", end:"%"', _id, _start, _end;
+        SELECT AVG(speedoverground), MAX(speedoverground), MAX(windspeedapparent), AVG(windspeedapparent), COUNT(*) INTO
+                avg_speed, max_speed, max_wind_speed, avg_wind_speed, count_metric
+            FROM api.metrics m
+            WHERE m.latitude IS NOT NULL
+                AND m.longitude IS NOT NULL
+                AND m.time >= _start::TIMESTAMPTZ
+                AND m.time <= _end::TIMESTAMPTZ
+                AND vessel_id = current_setting('vessel.id', false);
+        RAISE NOTICE '-> logbook_update_avg_fn avg for logbook id=%, avg_speed:%, max_speed:%, avg_wind_speed:%, max_wind_speed:%, count:%', _id, avg_speed, max_speed, avg_wind_speed, max_wind_speed, count_metric;
+    END;
+$logbook_update_avg$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.logbook_update_avg_fn
+    IS 'Update logbook details with calculate average and max data, AVG(speedOverGround), MAX(speedOverGround), MAX(windspeedapparent), count_metric';
+
+-- Update pending new logbook from process queue
+DROP FUNCTION IF EXISTS process_logbook_queue_fn;
+CREATE OR REPLACE FUNCTION process_logbook_queue_fn(IN _id integer) RETURNS void AS $process_logbook_queue$
+    DECLARE
+        logbook_rec record;
+        from_name text;
+        to_name text;
+        log_name text;
+        from_moorage record;
+        to_moorage record;
+        avg_rec record;
+        geo_rec record;
+        log_settings jsonb;
+        user_settings jsonb;
+        geojson jsonb;
+        extra_json jsonb;
+    BEGIN
+        -- If _id is not NULL
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> process_logbook_queue_fn invalid input %', _id;
+            RETURN;
+        END IF;
+        -- Get the logbook record with all necessary fields exist
+        SELECT * INTO logbook_rec
+            FROM api.logbook
+            WHERE active IS false
+                AND id = _id
+                AND _from_lng IS NOT NULL
+                AND _from_lat IS NOT NULL
+                AND _to_lng IS NOT NULL
+                AND _to_lat IS NOT NULL;
+        -- Ensure the query is successful
+        IF logbook_rec.vessel_id IS NULL THEN
+            RAISE WARNING '-> process_logbook_queue_fn invalid logbook %', _id;
+            RETURN;
+        END IF;
+
+        PERFORM set_config('vessel.id', logbook_rec.vessel_id, false);
+        --RAISE WARNING 'public.process_logbook_queue_fn() scheduler vessel.id %, user.id', current_setting('vessel.id', false), current_setting('user.id', false);
+
+        -- Calculate logbook data average and geo
+        -- Update logbook entry with the latest metric data and calculate data
+        avg_rec := logbook_update_avg_fn(logbook_rec.id, logbook_rec._from_time::TEXT, logbook_rec._to_time::TEXT);
+        geo_rec := logbook_update_geom_distance_fn(logbook_rec.id, logbook_rec._from_time::TEXT, logbook_rec._to_time::TEXT);
+
+        -- Do we have an existing moorage within 300m of the new log
+        -- generate logbook name, concat _from_location and _to_location from moorage name
+        from_moorage := process_lat_lon_fn(logbook_rec._from_lng::NUMERIC, logbook_rec._from_lat::NUMERIC);
+        to_moorage := process_lat_lon_fn(logbook_rec._to_lng::NUMERIC, logbook_rec._to_lat::NUMERIC);
+        SELECT CONCAT(from_moorage.moorage_name, ' to ' , to_moorage.moorage_name) INTO log_name;
+
+        -- Process `propulsion.*.runTime` and `navigation.log`
+        -- Calculate extra json
+        extra_json := logbook_update_extra_json_fn(logbook_rec.id, logbook_rec._from_time::TEXT, logbook_rec._to_time::TEXT);
+        -- add the avg_wind_speed
+        extra_json := extra_json || jsonb_build_object('avg_wind_speed', avg_rec.avg_wind_speed);
+
+        RAISE NOTICE 'Updating valid logbook entry logbook id:[%] start:[%] end:[%]', logbook_rec.id, logbook_rec._from_time, logbook_rec._to_time;
+        UPDATE api.logbook
+            SET
+                duration = (logbook_rec._to_time::TIMESTAMPTZ - logbook_rec._from_time::TIMESTAMPTZ),
+                avg_speed = avg_rec.avg_speed,
+                max_speed = avg_rec.max_speed,
+                max_wind_speed = avg_rec.max_wind_speed,
+                _from = from_moorage.moorage_name,
+                _from_moorage_id = from_moorage.moorage_id,
+                _to_moorage_id = to_moorage.moorage_id,
+                _to = to_moorage.moorage_name,
+                name = log_name,
+                track_geom = geo_rec._track_geom,
+                distance = geo_rec._track_distance,
+                extra = extra_json,
+                notes = NULL -- reset pre_log process
+            WHERE id = logbook_rec.id;
+
+        -- GeoJSON require track_geom field geometry linestring
+        geojson := logbook_update_geojson_fn(logbook_rec.id, logbook_rec._from_time::TEXT, logbook_rec._to_time::TEXT);
+        UPDATE api.logbook
+            SET
+                track_geojson = geojson
+            WHERE id = logbook_rec.id;
+
+        -- GeoJSON Timelapse require track_geojson geometry point
+        -- Add properties to the geojson for timelapse purpose
+        PERFORM public.logbook_timelapse_geojson_fn(logbook_rec.id);
+
+        -- Add post logbook entry to process queue for notification and QGIS processing
+        -- Require as we need the logbook to be updated with SQL commit
+        INSERT INTO process_queue (channel, payload, stored, ref_id)
+            VALUES ('post_logbook', logbook_rec.id, NOW(), current_setting('vessel.id', true));
+
+    END;
+$process_logbook_queue$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.process_logbook_queue_fn
+    IS 'Update logbook details when completed, logbook_update_avg_fn, logbook_update_geom_distance_fn, reverse_geocode_py_fn';
+
+-- Add avg_wind_speed to logbook geojson
+-- Add back truewindspeed and truewinddirection to logbook geojson
+DROP FUNCTION IF EXISTS public.logbook_update_geojson_fn;
+CREATE FUNCTION public.logbook_update_geojson_fn(IN _id integer, IN _start text, IN _end text,
+    OUT _track_geojson JSON
+ ) AS $logbook_geojson$
+    declare
+     log_geojson jsonb;
+     metrics_geojson jsonb;
+     _map jsonb;
+    begin
+        -- GeoJson Feature Logbook linestring
+        SELECT
+            ST_AsGeoJSON(log.*) into log_geojson
+        FROM
+           ( SELECT
+                id,name,
+                distance,
+                duration,
+                avg_speed,
+                max_speed,
+                max_wind_speed,
+                _from_time,
+                _to_time
+                _from_moorage_id,
+                _to_moorage_id,
+                notes,
+                extra['avg_wind_speed'] as avg_wind_speed,
+                track_geom
+                FROM api.logbook
+                WHERE id = _id
+           ) AS log;
+        -- GeoJson Feature Metrics point
+        SELECT
+            json_agg(ST_AsGeoJSON(t.*)::json) into metrics_geojson
+        FROM (
+            ( SELECT
+                time,
+                courseovergroundtrue,
+                speedoverground,
+                windspeedapparent,
+                longitude,latitude,
+                '' AS notes,
+                coalesce(metersToKnots((metrics->'environment.wind.speedTrue')::NUMERIC), null) as truewindspeed,
+                coalesce(radiantToDegrees((metrics->'environment.wind.directionTrue')::NUMERIC), null) as truewinddirection,
+                coalesce(status, null) as status,
+                st_makepoint(longitude,latitude) AS geo_point
+                FROM api.metrics m
+                WHERE m.latitude IS NOT NULL
+                    AND m.longitude IS NOT NULL
+                    AND time >= _start::TIMESTAMPTZ
+                    AND time <= _end::TIMESTAMPTZ
+                    AND vessel_id = current_setting('vessel.id', false)
+                ORDER BY m.time ASC
+            )
+        ) AS t;
+
+        -- Merge jsonb
+        SELECT log_geojson::jsonb || metrics_geojson::jsonb into _map;
+        -- output
+        SELECT
+            json_build_object(
+                'type', 'FeatureCollection',
+                'features', _map
+            ) into _track_geojson;
+    END;
+$logbook_geojson$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.logbook_update_geojson_fn
+    IS 'Update log details with geojson';
+
+-- Add properties to the geojson for timelapse purpose
+DROP FUNCTION IF EXISTS public.logbook_timelapse_geojson_fn;
+CREATE FUNCTION public.logbook_timelapse_geojson_fn(IN _id INT) returns void
+AS $logbook_timelapse$
+    declare
+        first_feature_note JSONB;
+        second_feature_note JSONB;
+        last_feature_note JSONB;
+        logbook_rec record;
+    begin
+        -- We need to fetch the processed logbook data.
+        SELECT name,duration,distance,_from,_to INTO logbook_rec
+            FROM api.logbook
+            WHERE active IS false
+                AND id = _id
+                AND _from_lng IS NOT NULL
+                AND _from_lat IS NOT NULL
+                AND _to_lng IS NOT NULL
+                AND _to_lat IS NOT NULL;
+        --raise warning '-> logbook_rec: %', logbook_rec;
+        select format('{"trip": { "name": "%s", "duration": "%s", "distance": "%s" }}', logbook_rec.name, logbook_rec.duration, logbook_rec.distance) into first_feature_note;
+        select format('{"notes": "%s"}', logbook_rec._from) into second_feature_note;
+        select format('{"notes": "%s"}', logbook_rec._to) into last_feature_note;
+        --raise warning '-> logbook_rec: % % %', first_feature_note, second_feature_note, last_feature_note;
+
+        -- Update the properties of the first feature, the second with geometry point
+        UPDATE api.logbook
+            SET track_geojson = jsonb_set(
+                track_geojson,
+                '{features, 1, properties}',
+                (track_geojson -> 'features' -> 1 -> 'properties' || first_feature_note)::jsonb
+            )
+            WHERE id = _id
+                and track_geojson -> 'features' -> 1 -> 'geometry' ->> 'type' = 'Point';
+
+        -- Update the properties of the third feature, the second with geometry point
+        UPDATE api.logbook
+            SET track_geojson = jsonb_set(
+                track_geojson,
+                '{features, 2, properties}',
+                (track_geojson -> 'features' -> 2 -> 'properties' || second_feature_note)::jsonb
+            )
+            where id = _id
+                and track_geojson -> 'features' -> 2 -> 'geometry' ->> 'type' = 'Point';
+
+        -- Update the properties of the last feature with geometry point
+        UPDATE api.logbook
+            SET track_geojson = jsonb_set(
+                track_geojson,
+                '{features, -1, properties}',
+                CASE
+                    WHEN COALESCE((track_geojson -> 'features' -> -1 -> 'properties' ->> 'notes'), '') = '' THEN
+                        (track_geojson -> 'features' -> -1 -> 'properties' || last_feature_note)::jsonb
+                    ELSE
+                        track_geojson -> 'features' -> -1 -> 'properties'
+                END
+            )
+            WHERE id = _id
+                and track_geojson -> 'features' -> -1 -> 'geometry' ->> 'type' = 'Point';
+end;
+$logbook_timelapse$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.logbook_timelapse_geojson_fn
+    IS 'Update logbook geojson, Add properties to some geojson features for timelapse purpose';
+
+-- CRON for signalk plugin upgrade
+-- The goal is to avoid error from old plugin version by enforcing upgrade.
+-- ERROR:  there is no unique or exclusion constraint matching the ON CONFLICT specification
+-- "POST /metadata?on_conflict=client_id HTTP/1.1" 400 137 "-" "postgsail.signalk v0.0.9"
+DROP FUNCTION IF EXISTS public.cron_process_skplugin_upgrade_fn;
+CREATE FUNCTION public.cron_process_skplugin_upgrade_fn() RETURNS void AS $skplugin_upgrade$
+DECLARE
+    skplugin_upgrade_rec record;
+    user_settings jsonb;
+BEGIN
+    -- Check for signalk plugin version
+    RAISE NOTICE 'cron_process_plugin_upgrade_fn';
+    FOR skplugin_upgrade_rec in
+        SELECT
+            v.owner_email,m.name,m.vessel_id,m.plugin_version,a.first
+            FROM api.metadata m
+            LEFT JOIN auth.vessels v ON v.vessel_id = m.vessel_id
+            LEFT JOIN auth.accounts a ON v.owner_email = a.email
+            WHERE m.plugin_version <= '0.3.0'
+    LOOP
+        RAISE NOTICE '-> cron_process_skplugin_upgrade_rec_fn for [%]', skplugin_upgrade_rec;
+        SELECT json_build_object('email', skplugin_upgrade_rec.owner_email, 'recipient', skplugin_upgrade_rec.first) into user_settings;
+        RAISE NOTICE '-> debug cron_process_skplugin_upgrade_rec_fn [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('skplugin_upgrade'::TEXT, user_settings::JSONB);
+    END LOOP;
+END;
+$skplugin_upgrade$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_skplugin_upgrade_fn
+    IS 'init by pg_cron, check for signalk plugin version and notify for upgrade';
+
+INSERT INTO public.email_templates ("name",email_subject,email_content,pushover_title,pushover_message)
+	VALUES ('skplugin_upgrade','PostgSail Signalk plugin upgrade',E'Hello __RECIPIENT__,\nPlease upgrade your postgsail signalk plugin. Be sure to contact me if you encounter any issue.','PostgSail Signalk plugin upgrade!',E'Please upgrade your postgsail signalk plugin.');
+
+DROP FUNCTION IF EXISTS public.metadata_ip_trigger_fn;
+-- Track IP per vessel to avoid abuse
+CREATE FUNCTION public.metadata_ip_trigger_fn() RETURNS trigger
+AS $metadata_ip_trigger$
+    DECLARE
+        headers   json := current_setting('request.headers', true)::json;
+        client_ip text := coalesce(headers->>'x-client-ip', NULL);
+    BEGIN
+        RAISE WARNING 'metadata_ip_trigger_fn [%] [%]', current_setting('vessel.id', true), client_ip;
+        IF client_ip IS NOT NULL THEN
+            UPDATE api.metadata
+                SET
+                     configuration = NEW.configuration || jsonb_build_object('ip', client_ip)
+                WHERE id = NEW.id;
+        END IF;
+        RETURN NULL;
+    END;
+$metadata_ip_trigger$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION public.metadata_ip_trigger_fn() IS 'Add IP from vessel in metadata, track abuse';
+
+DROP TRIGGER IF EXISTS metadata_ip_trigger ON api.metadata;
+-- Generate an error
+--CREATE TRIGGER metadata_ip_trigger BEFORE UPDATE ON api.metadata
+--    FOR EACH ROW EXECUTE FUNCTION metadata_ip_trigger_fn();
+-- Description
+--COMMENT ON TRIGGER
+--    metadata_ip_trigger ON api.metadata
+--    IS 'AFTER UPDATE ON api.metadata run function metadata_ip_trigger_fn for tracking vessel IP';
+
+DROP FUNCTION IF EXISTS public.logbook_active_geojson_fn;
+CREATE FUNCTION public.logbook_active_geojson_fn(
+    OUT _track_geojson jsonb
+ ) AS $logbook_active_geojson$
+BEGIN
+    WITH log_active AS (
+        SELECT * FROM api.logbook WHERE active IS True
+    ),
+        log_gis_line AS (
+            SELECT ST_MakeLine(
+                ARRAY(
+                    SELECT st_makepoint(longitude,latitude) AS geo_point
+                        FROM api.metrics m, log_active l
+                        WHERE m.latitude IS NOT NULL
+                            AND m.longitude IS NOT NULL
+                            AND m.time >= l._from_time::TIMESTAMPTZ
+                            AND m.time <= l._to_time::TIMESTAMPTZ
+                        ORDER BY m.time ASC
+                )
+            )
+    ),
+        log_gis_point AS (
+            SELECT
+                ST_AsGeoJSON(t.*)::json AS GeoJSONPoint
+            FROM (
+                ( SELECT
+                    time,
+                    courseovergroundtrue,
+                    speedoverground,
+                    windspeedapparent,
+                    longitude,latitude,
+                    '' AS notes,
+                    coalesce(metersToKnots((metrics->'environment.wind.speedTrue')::NUMERIC), null) as truewindspeed,
+                    coalesce(radiantToDegrees((metrics->'environment.wind.directionTrue')::NUMERIC), null) as truewinddirection,
+                    coalesce(status, null) AS status,
+                    st_makepoint(longitude,latitude) AS geo_point
+                    FROM api.metrics m
+                    WHERE m.latitude IS NOT NULL
+                        AND m.longitude IS NOT NULL
+                    ORDER BY m.time DESC LIMIT 1
+                )
+            ) as t
+    ),
+    log_agg as (
+        SELECT
+            CASE WHEN log_gis_line.st_makeline IS NOT NULL THEN
+                ( SELECT jsonb_agg(ST_AsGeoJSON(log_gis_line.*)::json)::jsonb AS GeoJSONLine FROM log_gis_line )
+            ELSE
+                ( SELECT '[]'::json AS GeoJSONLine )::jsonb
+            END
+        FROM log_gis_line
+    )
+    SELECT
+            jsonb_build_object(
+                'type', 'FeatureCollection',
+                'features', log_agg.GeoJSONLine::jsonb || log_gis_point.GeoJSONPoint::jsonb
+                ) INTO _track_geojson FROM log_agg, log_gis_point;
+END;
+$logbook_active_geojson$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.logbook_active_geojson_fn
+    IS 'Create a GeoJSON with 2 features, LineString with a current active log and Point with the last position';
+
+-- Update monitoring view to support live trip and truewindspeed and truewinddirection to stationary GeoJSON.
+DROP VIEW IF EXISTS api.monitoring_view;
+CREATE VIEW api.monitoring_view WITH (security_invoker=true,security_barrier=true) AS
+    SELECT
+        time AS "time",
+        (NOW() AT TIME ZONE 'UTC' - time) > INTERVAL '70 MINUTES' as offline,
+        metrics-> 'environment.water.temperature' AS waterTemperature,
+        metrics-> 'environment.inside.temperature' AS insideTemperature,
+        metrics-> 'environment.outside.temperature' AS outsideTemperature,
+        metrics-> 'environment.wind.speedOverGround' AS windSpeedOverGround,
+        metrics-> 'environment.wind.directionTrue' AS windDirectionTrue,
+        metrics-> 'environment.inside.relativeHumidity' AS insideHumidity,
+        metrics-> 'environment.outside.relativeHumidity' AS outsideHumidity,
+        metrics-> 'environment.outside.pressure' AS outsidePressure,
+        metrics-> 'environment.inside.pressure' AS insidePressure,
+        metrics-> 'electrical.batteries.House.capacity.stateOfCharge' AS batteryCharge,
+        metrics-> 'electrical.batteries.House.voltage' AS batteryVoltage,
+        metrics-> 'environment.depth.belowTransducer' AS depth,
+        jsonb_build_object(
+            'type', 'Feature',
+            'geometry', ST_AsGeoJSON(st_makepoint(longitude,latitude))::jsonb,
+            'properties', jsonb_build_object(
+                'name', current_setting('vessel.name', false),
+                'latitude', m.latitude,
+                'longitude', m.longitude,
+                'time', m.time,
+                'speedoverground', m.speedoverground,
+                'windspeedapparent', m.windspeedapparent,
+                'truewindspeed', coalesce(metersToKnots((metrics->'environment.wind.speedTrue')::NUMERIC), null),
+                'truewinddirection', coalesce(radiantToDegrees((metrics->'environment.wind.directionTrue')::NUMERIC), null),
+                'status', coalesce(m.status, null)
+                )::jsonb ) AS geojson,
+        current_setting('vessel.name', false) AS name,
+        m.status,
+        CASE WHEN m.status <> 'moored' THEN (
+            SELECT public.logbook_active_geojson_fn() )
+        END AS live
+    FROM api.metrics m
+    ORDER BY time DESC LIMIT 1;
+-- Description
+COMMENT ON VIEW
+    api.monitoring_view
+    IS 'Monitoring static web view';
+
+-- Allow to access tables for user_role and grafana and api_anonymous
+GRANT SELECT ON ALL TABLES IN SCHEMA api TO user_role;
+GRANT SELECT ON ALL TABLES IN SCHEMA api TO grafana;
+GRANT SELECT ON TABLE api.monitoring_view TO user_role;
+GRANT SELECT ON TABLE api.monitoring_view TO api_anonymous;
+GRANT SELECT ON TABLE api.monitoring_view TO grafana;
+
+-- Allow to execute fn for user_role and grafana and api_anonymous
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA api TO user_role;
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA api TO grafana;
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO user_role;
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO grafana;
+GRANT EXECUTE ON FUNCTION public.logbook_active_geojson_fn TO api_anonymous;
+GRANT EXECUTE ON FUNCTION public.metersToKnots TO api_anonymous;
+GRANT EXECUTE ON FUNCTION public.radiantToDegrees TO api_anonymous;
+
+-- Fix vessel name (Organization) ensure we have a value either from metadata tbl (signalk) or from vessel tbl
+DROP FUNCTION IF EXISTS public.cron_process_grafana_fn;
+CREATE OR REPLACE FUNCTION public.cron_process_grafana_fn() RETURNS void
+AS $cron_process_grafana_fn$
+DECLARE
+    process_rec record;
+    data_rec record;
+    app_settings jsonb;
+    user_settings jsonb;
+BEGIN
+    -- We run grafana provisioning only after the first received vessel metadata
+    -- Check for new vessel metadata pending grafana provisioning
+    RAISE NOTICE 'cron_process_grafana_fn';
+    FOR process_rec in
+        SELECT * from process_queue
+            where channel = 'grafana' and processed is null
+            order by stored asc
+    LOOP
+        RAISE NOTICE '-> cron_process_grafana_fn [%]', process_rec.payload;
+        -- Gather url from app settings
+        app_settings := get_app_settings_fn();
+        -- Get vessel details base on metadata id
+        SELECT
+            v.owner_email,coalesce(m.name,v.name) as name,m.vessel_id into data_rec
+            FROM auth.vessels v
+            LEFT JOIN api.metadata m ON v.vessel_id = m.vessel_id
+            WHERE m.id = process_rec.payload::INTEGER;
+        IF data_rec.vessel_id IS NULL OR data_rec.name IS NULL THEN
+            RAISE WARNING '-> DEBUG cron_process_grafana_fn grafana_py_fn error [%]', data_rec;
+            RETURN;
+        END IF;
+        -- as we got data from the vessel we can do the grafana provisioning.
+        RAISE DEBUG '-> DEBUG cron_process_grafana_fn grafana_py_fn provisioning [%]', data_rec;
+        PERFORM grafana_py_fn(data_rec.name, data_rec.vessel_id, data_rec.owner_email, app_settings);
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(data_rec.vessel_id::TEXT);
+        RAISE DEBUG '-> DEBUG cron_process_grafana_fn get_user_settings_from_vesselid_fn [%]', user_settings;
+        -- add user in keycloak
+        PERFORM keycloak_auth_py_fn(data_rec.vessel_id, user_settings, app_settings);
+        -- Send notification
+        PERFORM send_notification_fn('grafana'::TEXT, user_settings::JSONB);
+        -- update process_queue entry as processed
+        UPDATE process_queue
+            SET
+                processed = NOW()
+            WHERE id = process_rec.id;
+        RAISE NOTICE '-> cron_process_grafana_fn updated process_queue table [%]', process_rec.id;
+    END LOOP;
+END;
+$cron_process_grafana_fn$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_grafana_fn
+    IS 'init by pg_cron to check for new vessel pending grafana provisioning, if so perform grafana_py_fn';
+
+-- Update version
+UPDATE public.app_settings
+	SET value='0.7.3'
+	WHERE "name"='app.version';
+
+\c postgres
+
+-- Notifications/Reminders for old signalk plugin
+-- At 08:06 on Sunday.
+-- At 08:06 on every 4th day-of-month if it's on Sunday.
+SELECT cron.schedule('cron_skplugin_upgrade', '6 8 */4 * 0', 'select public.cron_process_skplugin_upgrade_fn()');
+UPDATE cron.job	SET database = 'postgres' WHERE jobname = 'cron_skplugin_upgrade';

initdb/99_migrations_202406.sql

@@ -0,0 +1,879 @@
+---------------------------------------------------------------------------
+-- Copyright 2021-2024 Francois Lacroix <xbgmsharp@gmail.com>
+-- This file is part of PostgSail which is released under Apache License, Version 2.0 (the "License").
+-- See file LICENSE or go to http://www.apache.org/licenses/LICENSE-2.0 for full license details.
+--
+-- Migration June 2024
+--
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+\echo 'Timing mode is enabled'
+\timing
+
+\echo 'Force timezone, just in case'
+set timezone to 'UTC';
+
+-- Add video timelapse notification message
+INSERT INTO public.email_templates ("name",email_subject,email_content,pushover_title,pushover_message)
+	VALUES ('video_ready','PostgSail Video ready',E'Hey,\nYour video is available at __VIDEO_LINK__.\nPlease make sure you download your video as it will delete in 7 days.','PostgSail Video ready!',E'Your video is ready __VIDEO_LINK__.');
+
+-- Generate and request the logbook image url to be cache on QGIS server.
+DROP FUNCTION IF EXISTS public.qgis_getmap_py_fn;
+CREATE OR REPLACE FUNCTION public.qgis_getmap_py_fn(IN vessel_id TEXT DEFAULT NULL, IN log_id NUMERIC DEFAULT NULL, IN extent TEXT DEFAULT NULL, IN logs_url BOOLEAN DEFAULT False) RETURNS VOID
+AS $qgis_getmap_py$
+	import requests
+
+	# Extract extent
+	def parse_extent_from_db(extent_raw):
+	    # Parse the extent_raw to extract coordinates
+	    extent = extent_raw.replace('BOX(', '').replace(')', '').split(',')
+	    min_x, min_y = map(float, extent[0].split())
+	    max_x, max_y = map(float, extent[1].split())
+	    return min_x, min_y, max_x, max_y
+
+	# ZoomOut from linestring extent 
+	def apply_scale_factor(extent, scale_factor=1.125):
+	    min_x, min_y, max_x, max_y = extent
+	    center_x = (min_x + max_x) / 2
+	    center_y = (min_y + max_y) / 2
+	    width = max_x - min_x
+	    height = max_y - min_y
+	    new_width = width * scale_factor
+	    new_height = height * scale_factor
+	    scaled_extent = (
+	        round(center_x - new_width / 2),
+	        round(center_y - new_height / 2),
+	        round(center_x + new_width / 2),
+	        round(center_y + new_height / 2),
+	    )
+	    return scaled_extent
+
+	def adjust_image_size_to_bbox(extent, width, height):
+	    min_x, min_y, max_x, max_y = extent
+	    bbox_aspect_ratio = (max_x - min_x) / (max_y - min_y)
+	    image_aspect_ratio = width / height
+	
+	    if bbox_aspect_ratio > image_aspect_ratio:
+	        # Adjust height to match aspect ratio
+	        height = width / bbox_aspect_ratio
+	    else:
+	        # Adjust width to match aspect ratio
+	        width = height * bbox_aspect_ratio
+	
+	    return int(width), int(height)
+
+	def calculate_width(extent, fixed_height):
+	    min_x, min_y, max_x, max_y = extent
+	    bbox_aspect_ratio = (max_x - min_x) / (max_y - min_y)
+	    width = fixed_height * bbox_aspect_ratio
+	    return int(width)
+
+	def adjust_bbox_to_fixed_size(scaled_extent, fixed_width, fixed_height):
+	    min_x, min_y, max_x, max_y = scaled_extent
+	    bbox_width = max_x - min_x
+	    bbox_height = max_y - min_y
+	    bbox_aspect_ratio = bbox_width / bbox_height
+	    image_aspect_ratio = fixed_width / fixed_height
+	
+	    if bbox_aspect_ratio > image_aspect_ratio:
+	        # Adjust height to match aspect ratio
+	        new_bbox_height = bbox_width / image_aspect_ratio
+	        height_diff = new_bbox_height - bbox_height
+	        min_y -= height_diff / 2
+	        max_y += height_diff / 2
+	    else:
+	        # Adjust width to match aspect ratio
+	        new_bbox_width = bbox_height * image_aspect_ratio
+	        width_diff = new_bbox_width - bbox_width
+	        min_x -= width_diff / 2
+	        max_x += width_diff / 2
+	
+	    adjusted_extent = (min_x, min_y, max_x, max_y)
+	    return adjusted_extent
+
+	def generate_getmap_url(server_url, project_path, layer_name, extent, width=1080, height=566, crs="EPSG:3857", format="image/png"):
+	    min_x, min_y, max_x, max_y = extent
+	    bbox = f"{min_x},{min_y},{max_x},{max_y}"
+
+	    # Adjust image size to match BBOX aspect ratio
+	    #width, height = adjust_image_size_to_bbox(extent, width, height)
+
+	    # Calculate width to maintain aspect ratio with fixed height
+	    #width = calculate_width(extent, height)
+
+	    url = (
+	        f"{server_url}?SERVICE=WMS&VERSION=1.3.0&REQUEST=GetMap&FORMAT={format}&CRS={crs}"
+	        f"&BBOX={bbox}&WIDTH={width}&HEIGHT={height}&LAYERS={layer_name}&MAP={project_path}"
+	    )
+	    return url
+
+	if logs_url == False:
+		server_url = f"https://gis.openplotter.cloud/log_{vessel_id}_{log_id}.png".format(vessel_id, log_id)
+	else:
+		server_url = f"https://gis.openplotter.cloud/logs_{vessel_id}_{log_id}.png".format(vessel_id, log_id)
+	project_path = "/projects/postgsail5.qgz"
+	layer_name = "OpenStreetMap,SQLLayer"
+	#plpy.notice('qgis_getmap_py vessel_id [{}], log_id [{}], extent [{}]'.format(vessel_id, log_id, extent))
+
+	# Parse extent and scale factor
+	scaled_extent = apply_scale_factor(parse_extent_from_db(extent))
+	#plpy.notice('qgis_getmap_py scaled_extent [{}]'.format(scaled_extent))
+
+	fixed_width = 1080
+	fixed_height = 566
+	adjusted_extent = adjust_bbox_to_fixed_size(scaled_extent, fixed_width, fixed_height)
+	#plpy.notice('qgis_getmap_py adjusted_extent [{}]'.format(adjusted_extent))
+
+	getmap_url = generate_getmap_url(server_url, project_path, layer_name, adjusted_extent)
+	if logs_url == False:
+		filter_url = f"{getmap_url}&FILTER=SQLLayer:\"vessel_id\" = '{vessel_id}' AND \"id\" = {log_id}".format(getmap_url, vessel_id, log_id)
+	else:
+		filter_url = f"{getmap_url}&FILTER=SQLLayer:\"vessel_id\" = '{vessel_id}'".format(getmap_url, vessel_id)
+	#plpy.notice('qgis_getmap_py getmap_url [{}]'.format(filter_url))
+
+	# Fetch image to be cache in qgis server
+	headers = {"User-Agent": "PostgSail", "From": "xbgmsharp@gmail.com"}
+	r = requests.get(filter_url, headers=headers, timeout=100)
+	# Parse response
+	if r.status_code != 200:
+		plpy.warning('Failed to get WMS image, url[{}]'.format(filter_url))
+$qgis_getmap_py$ LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.qgis_getmap_py_fn
+    IS 'Generate a log map, to generate the cache data for faster access later';
+
+-- Generate the logbook extent for the logbook image to access the QGIS server.
+DROP FUNCTION IF EXISTS public.qgis_bbox_py_fn;
+CREATE OR REPLACE FUNCTION public.qgis_bbox_py_fn(IN vessel_id TEXT DEFAULT NULL, IN log_id NUMERIC DEFAULT NULL, IN width NUMERIC DEFAULT 1080, IN height NUMERIC DEFAULT 566, IN scaleout BOOLEAN DEFAULT True, OUT bbox TEXT)
+AS $qgis_bbox_py$
+	log_extent = None
+	# If we have a vessel_id then it is logs image map
+	if vessel_id:
+		# Use the shared cache to avoid preparing the log extent
+		if vessel_id in SD:
+			plan = SD[vessel_id]
+		# A prepared statement from Python
+		else:
+			plan = plpy.prepare("WITH merged AS ( SELECT ST_Union(track_geom) AS merged_geometry FROM api.logbook WHERE vessel_id = $1 ) SELECT ST_Extent(ST_Transform(merged_geometry, 3857))::TEXT FROM merged;", ["text"])
+			SD[vessel_id] = plan
+		# Execute the statement with the log extent param and limit to 1 result
+		rv = plpy.execute(plan, [vessel_id], 1)
+		log_extent = rv[0]['st_extent']
+    # Else we have a log_id then it is single log image map
+	else:
+		# Use the shared cache to avoid preparing the log extent
+		if log_id in SD:
+			plan = SD[log_id]
+		# A prepared statement from Python
+		else:
+			plan = plpy.prepare("SELECT ST_Extent(ST_Transform(track_geom, 3857)) FROM api.logbook WHERE id = $1::NUMERIC", ["text"])
+			SD[log_id] = plan
+		# Execute the statement with the log extent param and limit to 1 result
+		rv = plpy.execute(plan, [log_id], 1)
+		log_extent = rv[0]['st_extent']
+
+	# Extract extent
+	def parse_extent_from_db(extent_raw):
+	    # Parse the extent_raw to extract coordinates
+	    extent = extent_raw.replace('BOX(', '').replace(')', '').split(',')
+	    min_x, min_y = map(float, extent[0].split())
+	    max_x, max_y = map(float, extent[1].split())
+	    return min_x, min_y, max_x, max_y
+	
+	# ZoomOut from linestring extent 
+	def apply_scale_factor(extent, scale_factor=1.125):
+	    min_x, min_y, max_x, max_y = extent
+	    center_x = (min_x + max_x) / 2
+	    center_y = (min_y + max_y) / 2
+	    width = max_x - min_x
+	    height = max_y - min_y
+	    new_width = width * scale_factor
+	    new_height = height * scale_factor
+	    scaled_extent = (
+	        round(center_x - new_width / 2),
+	        round(center_y - new_height / 2),
+	        round(center_x + new_width / 2),
+	        round(center_y + new_height / 2),
+	    )
+	    return scaled_extent
+
+	def adjust_bbox_to_fixed_size(scaled_extent, fixed_width, fixed_height):
+	    min_x, min_y, max_x, max_y = scaled_extent
+	    bbox_width = float(max_x - min_x)
+	    bbox_height = float(max_y - min_y)
+	    bbox_aspect_ratio = float(bbox_width / bbox_height)
+	    image_aspect_ratio = float(fixed_width / fixed_height)
+	
+	    if bbox_aspect_ratio > image_aspect_ratio:
+	        # Adjust height to match aspect ratio
+	        new_bbox_height = bbox_width / image_aspect_ratio
+	        height_diff = new_bbox_height - bbox_height
+	        min_y -= height_diff / 2
+	        max_y += height_diff / 2
+	    else:
+	        # Adjust width to match aspect ratio
+	        new_bbox_width = bbox_height * image_aspect_ratio
+	        width_diff = new_bbox_width - bbox_width
+	        min_x -= width_diff / 2
+	        max_x += width_diff / 2
+
+	    adjusted_extent = (min_x, min_y, max_x, max_y)
+	    return adjusted_extent
+
+	if not log_extent:
+	    plpy.warning('Failed to get sql qgis_bbox_py log_id [{}], extent [{}]'.format(log_id, log_extent))
+	#plpy.notice('qgis_bbox_py log_id [{}], extent [{}]'.format(log_id, log_extent))
+	# Parse extent and apply ZoomOut scale factor
+	if scaleout:
+		scaled_extent = apply_scale_factor(parse_extent_from_db(log_extent))
+	else:
+		scaled_extent = parse_extent_from_db(log_extent)
+	#plpy.notice('qgis_bbox_py log_id [{}], scaled_extent [{}]'.format(log_id, scaled_extent))
+	fixed_width = width # default 1080
+	fixed_height = height # default 566
+	adjusted_extent = adjust_bbox_to_fixed_size(scaled_extent, fixed_width, fixed_height)
+	#plpy.notice('qgis_bbox_py log_id [{}], adjusted_extent [{}]'.format(log_id, adjusted_extent))
+	min_x, min_y, max_x, max_y = adjusted_extent
+	return f"{min_x},{min_y},{max_x},{max_y}"
+$qgis_bbox_py$ LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.qgis_bbox_py_fn
+    IS 'Generate the BBOX base on log extent and adapt extent to the image size for QGIS Server';
+
+-- qgis_role user and role with login, read-only on auth.accounts, limit 20 connections
+CREATE ROLE qgis_role WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS NOREPLICATION CONNECTION LIMIT 20 LOGIN PASSWORD 'mysecretpassword';
+COMMENT ON ROLE qgis_role IS
+    'Role use by QGIS server and Apache to connect and lookup the logbook table.';
+-- Allow read on VIEWS on API schema
+GRANT USAGE ON SCHEMA api TO qgis_role;
+GRANT SELECT ON TABLE api.logbook TO qgis_role;
+GRANT USAGE ON SCHEMA public TO qgis_role;
+-- For all postgis fn, st_extent, st_transform
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO qgis_role;
+-- Allow qgis_role to select all logbook records
+CREATE POLICY logbook_qgis_role ON api.logbook TO qgis_role
+    USING (true)
+    WITH CHECK (false);
+
+-- Add support for HTML email with image inline for logbook
+-- Add support for video link for maplapse
+DROP FUNCTION IF EXISTS public.send_email_py_fn;
+CREATE OR REPLACE FUNCTION public.send_email_py_fn(IN email_type TEXT, IN _user JSONB, IN app JSONB) RETURNS void
+AS $send_email_py$
+    # Import smtplib for the actual sending function
+    import smtplib
+    import requests
+
+    # Import the email modules we need
+    from email.message import EmailMessage
+    from email.utils import formatdate,make_msgid
+    from email.mime.text import MIMEText
+
+    # Use the shared cache to avoid preparing the email metadata
+    if email_type in SD:
+        plan = SD[email_type]
+    # A prepared statement from Python
+    else:
+        plan = plpy.prepare("SELECT * FROM email_templates WHERE name = $1", ["text"])
+        SD[email_type] = plan
+
+    # Execute the statement with the email_type param and limit to 1 result
+    rv = plpy.execute(plan, [email_type], 1)
+    email_subject = rv[0]['email_subject']
+    email_content = rv[0]['email_content']
+
+    # Replace fields using input jsonb obj
+    if not _user or not app:
+        plpy.notice('send_email_py_fn Parameters [{}] [{}]'.format(_user, app))
+        plpy.error('Error missing parameters')
+        return None
+    if 'logbook_name' in _user and _user['logbook_name']:
+        email_content = email_content.replace('__LOGBOOK_NAME__', _user['logbook_name'])
+    if 'logbook_link' in _user and _user['logbook_link']:
+        email_content = email_content.replace('__LOGBOOK_LINK__', str(_user['logbook_link']))
+    if 'logbook_img' in _user and _user['logbook_img']:
+        email_content = email_content.replace('__LOGBOOK_IMG__', str(_user['logbook_img']))
+    if 'video_link' in _user and _user['video_link']:
+        email_content = email_content.replace('__VIDEO_LINK__', str( _user['video_link']))
+    if 'recipient' in _user and _user['recipient']:
+        email_content = email_content.replace('__RECIPIENT__', _user['recipient'])
+    if 'boat' in _user and _user['boat']:
+        email_content = email_content.replace('__BOAT__', _user['boat'])
+    if 'badge' in _user and _user['badge']:
+        email_content = email_content.replace('__BADGE_NAME__', _user['badge'])
+    if 'otp_code' in _user and _user['otp_code']:
+        email_content = email_content.replace('__OTP_CODE__', _user['otp_code'])
+    if 'reset_qs' in _user and _user['reset_qs']:
+        email_content = email_content.replace('__RESET_QS__', _user['reset_qs'])
+    if 'alert' in _user and _user['alert']:
+        email_content = email_content.replace('__ALERT__', _user['alert'])
+
+    if 'app.url' in app and app['app.url']:
+        email_content = email_content.replace('__APP_URL__', app['app.url'])
+
+    email_from = 'root@localhost'
+    if 'app.email_from' in app and app['app.email_from']:
+        email_from = 'PostgSail <' + app['app.email_from'] + '>'
+    #plpy.notice('Sending email from [{}] [{}]'.format(email_from, app['app.email_from']))
+
+    email_to = 'root@localhost'
+    if 'email' in _user and _user['email']:
+        email_to = _user['email']
+        #plpy.notice('Sending email to [{}] [{}]'.format(email_to, _user['email']))
+    else:
+        plpy.error('Error email to')
+        return None
+
+    if email_type == 'logbook':
+        msg = EmailMessage()
+        msg.set_content(email_content)
+    else:
+        msg = MIMEText(email_content, 'plain', 'utf-8')
+    msg["Subject"] = email_subject
+    msg["From"] = email_from
+    msg["To"] = email_to
+    msg["Date"] = formatdate()
+    msg["Message-ID"] = make_msgid()
+
+    if email_type == 'logbook' and 'logbook_img' in _user and _user['logbook_img']:
+        # Create a Content-ID for the image
+        image_cid = make_msgid()
+        # Set an alternative html body
+        msg.add_alternative("""\
+<html>
+    <body>
+        <p>{email_content}</p>
+        <img src="cid:{image_cid}">
+    </body>
+</html>
+""".format(email_content=email_content, image_cid=image_cid[1:-1]), subtype='html')
+        img_url = 'https://gis.openplotter.cloud/{}'.format(str(_user['logbook_img']))
+        response = requests.get(img_url, stream=True)
+        if response.status_code == 200:
+            msg.get_payload()[1].add_related(response.raw.data,
+                                            maintype='image', 
+                                            subtype='png', 
+                                            cid=image_cid)
+
+    server_smtp = 'localhost'
+    if 'app.email_server' in app and app['app.email_server']:
+        server_smtp = app['app.email_server']
+    #plpy.notice('Sending server [{}] [{}]'.format(server_smtp, app['app.email_server']))
+
+    # Send the message via our own SMTP server.
+    try:
+        # send your message with credentials specified above
+        with smtplib.SMTP(server_smtp, 587) as server:
+            if 'app.email_user' in app and app['app.email_user'] \
+                and 'app.email_pass' in app and app['app.email_pass']:
+                server.starttls()
+                server.login(app['app.email_user'], app['app.email_pass'])
+            #server.send_message(msg)
+            server.sendmail(msg["From"], msg["To"], msg.as_string())
+            server.quit()
+        # tell the script to report if your message was sent or which errors need to be fixed
+        plpy.notice('Sent email successfully to [{}] [{}]'.format(msg["To"], msg["Subject"]))
+        return None
+    except OSError as error:
+        plpy.error('OS Error occurred: ' + str(error))
+    except smtplib.SMTPConnectError:
+        plpy.error('Failed to connect to the server. Bad connection settings?')
+    except smtplib.SMTPServerDisconnected:
+        plpy.error('Failed to connect to the server. Wrong user/password?')
+    except smtplib.SMTPException as e:
+        plpy.error('SMTP error occurred: ' + str(e))
+$send_email_py$ TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.send_email_py_fn
+    IS 'Send email notification using plpython3u';
+
+-- Add vessel_id key, expose vessel_id
+DROP FUNCTION IF EXISTS api.vessel_fn;
+CREATE OR REPLACE FUNCTION api.vessel_fn(OUT vessel JSON) RETURNS JSON
+AS $vessel$
+    DECLARE
+    BEGIN
+        SELECT
+            jsonb_build_object(
+                'name', coalesce(m.name, null),
+                'mmsi', coalesce(m.mmsi, null),
+                'vessel_id', m.vessel_id,
+                'created_at', v.created_at,
+                'first_contact', coalesce(m.created_at, null),
+                'last_contact', coalesce(m.time, null),
+                'geojson', coalesce(ST_AsGeoJSON(geojson_t.*)::json, null)
+            )::jsonb || api.vessel_details_fn()::jsonb
+            INTO vessel
+            FROM auth.vessels v, api.metadata m, 
+                (	select
+                        current_setting('vessel.name') as name,
+                        time,
+                        courseovergroundtrue,
+                        speedoverground,
+                        anglespeedapparent,
+                        longitude,latitude,
+                        st_makepoint(longitude,latitude) AS geo_point
+                        FROM api.metrics
+                        WHERE
+                            latitude IS NOT NULL
+                            AND longitude IS NOT NULL
+                            AND vessel_id = current_setting('vessel.id', false)
+                        ORDER BY time DESC LIMIT 1
+                ) AS geojson_t
+            WHERE
+                m.vessel_id = current_setting('vessel.id')
+                AND m.vessel_id = v.vessel_id;
+        --RAISE notice 'api.vessel_fn %', obj;
+    END;
+$vessel$ language plpgsql security definer;
+-- Description
+COMMENT ON FUNCTION
+    api.vessel_fn
+    IS 'Expose vessel details to API';
+
+-- Update pending new logbook from process queue
+DROP FUNCTION IF EXISTS public.process_post_logbook_fn;
+CREATE OR REPLACE FUNCTION public.process_post_logbook_fn(IN _id integer) RETURNS void AS $process_post_logbook_queue$
+    DECLARE
+        logbook_rec record;
+        log_settings jsonb;
+        user_settings jsonb;
+        extra_json jsonb;
+        log_img_url text;
+        logs_img_url text;
+        extent_bbox text;
+    BEGIN
+        -- If _id is not NULL
+        IF _id IS NULL OR _id < 1 THEN
+            RAISE WARNING '-> process_post_logbook_fn invalid input %', _id;
+            RETURN;
+        END IF;
+        -- Get the logbook record with all necessary fields exist
+        SELECT * INTO logbook_rec
+            FROM api.logbook
+            WHERE active IS false
+                AND id = _id
+                AND _from_lng IS NOT NULL
+                AND _from_lat IS NOT NULL
+                AND _to_lng IS NOT NULL
+                AND _to_lat IS NOT NULL;
+        -- Ensure the query is successful
+        IF logbook_rec.vessel_id IS NULL THEN
+            RAISE WARNING '-> process_post_logbook_fn invalid logbook %', _id;
+            RETURN;
+        END IF;
+
+        PERFORM set_config('vessel.id', logbook_rec.vessel_id, false);
+        --RAISE WARNING 'public.process_post_logbook_fn() scheduler vessel.id %, user.id', current_setting('vessel.id', false), current_setting('user.id', false);
+
+        -- Generate logbook image map name from QGIS
+        SELECT CONCAT('log_', logbook_rec.vessel_id::TEXT, '_', logbook_rec.id, '.png') INTO log_img_url;
+        SELECT ST_Extent(ST_Transform(logbook_rec.track_geom, 3857))::TEXT AS envelope INTO extent_bbox FROM api.logbook WHERE id = logbook_rec.id;
+        PERFORM public.qgis_getmap_py_fn(logbook_rec.vessel_id::TEXT, logbook_rec.id, extent_bbox::TEXT, False);
+        -- Generate logs image map name from QGIS
+        WITH merged AS (
+            SELECT ST_Union(logbook_rec.track_geom) AS merged_geometry
+                FROM api.logbook WHERE vessel_id = logbook_rec.vessel_id
+        )
+        SELECT ST_Extent(ST_Transform(merged_geometry, 3857))::TEXT AS envelope INTO extent_bbox FROM merged;
+        SELECT CONCAT('logs_', logbook_rec.vessel_id::TEXT, '_', logbook_rec.id, '.png') INTO logs_img_url;
+        PERFORM public.qgis_getmap_py_fn(logbook_rec.vessel_id::TEXT, logbook_rec.id, extent_bbox::TEXT, True);
+
+        -- Prepare notification, gather user settings
+        SELECT json_build_object('logbook_name', logbook_rec.name, 'logbook_link', logbook_rec.id, 'logbook_img', log_img_url) INTO log_settings;
+        user_settings := get_user_settings_from_vesselid_fn(logbook_rec.vessel_id::TEXT);
+        SELECT user_settings::JSONB || log_settings::JSONB into user_settings;
+        RAISE NOTICE '-> debug process_post_logbook_fn get_user_settings_from_vesselid_fn [%]', user_settings;
+        RAISE NOTICE '-> debug process_post_logbook_fn log_settings [%]', log_settings;
+        -- Send notification
+        PERFORM send_notification_fn('logbook'::TEXT, user_settings::JSONB);
+        -- Process badges
+        RAISE NOTICE '-> debug process_post_logbook_fn user_settings [%]', user_settings->>'email'::TEXT;
+        PERFORM set_config('user.email', user_settings->>'email'::TEXT, false);
+        PERFORM badges_logbook_fn(logbook_rec.id, logbook_rec._to_time::TEXT);
+        PERFORM badges_geom_fn(logbook_rec.id, logbook_rec._to_time::TEXT);
+    END;
+$process_post_logbook_queue$ LANGUAGE plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.process_post_logbook_fn
+    IS 'Generate QGIS image and Notify user for new logbook.';
+
+-- Check for new logbook pending notification
+DROP FUNCTION IF EXISTS public.cron_process_post_logbook_fn;
+CREATE FUNCTION public.cron_process_post_logbook_fn() RETURNS void AS $$
+DECLARE
+    process_rec record;
+BEGIN
+    -- Check for new logbook pending update
+    RAISE NOTICE 'cron_process_post_logbook_fn init loop';
+    FOR process_rec in
+        SELECT * FROM process_queue
+            WHERE channel = 'post_logbook' AND processed IS NULL
+            ORDER BY stored ASC LIMIT 100
+    LOOP
+        RAISE NOTICE 'cron_process_post_logbook_fn processing queue [%] for logbook id [%]', process_rec.id, process_rec.payload;
+        -- update logbook
+        PERFORM process_post_logbook_fn(process_rec.payload::INTEGER);
+        -- update process_queue table , processed
+        UPDATE process_queue
+            SET
+                processed = NOW()
+            WHERE id = process_rec.id;
+        RAISE NOTICE 'cron_process_post_logbook_fn processed queue [%] for logbook id [%]', process_rec.id, process_rec.payload;
+    END LOOP;
+END;
+$$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_post_logbook_fn
+    IS 'init by pg_cron to check for new logbook pending qgis and notification, after process_new_logbook_fn';
+
+DROP FUNCTION IF EXISTS public.run_cron_jobs;
+CREATE FUNCTION public.run_cron_jobs() RETURNS void AS $$
+BEGIN
+    -- In correct order
+    perform public.cron_process_new_notification_fn();
+    perform public.cron_process_monitor_online_fn();
+    --perform public.cron_process_grafana_fn();
+    perform public.cron_process_pre_logbook_fn();
+    perform public.cron_process_new_logbook_fn();
+    perform public.cron_process_post_logbook_fn();
+    perform public.cron_process_new_stay_fn();
+    --perform public.cron_process_new_moorage_fn();
+    perform public.cron_process_monitor_offline_fn();
+END
+$$ language plpgsql;
+
+DROP VIEW IF EXISTS api.eventlogs_view;
+CREATE VIEW api.eventlogs_view WITH (security_invoker=true,security_barrier=true) AS
+    SELECT pq.*
+        FROM public.process_queue pq
+        WHERE channel <> 'pre_logbook' 
+            AND channel <> 'post_logbook'
+            AND (ref_id = current_setting('user.id', true)
+            OR ref_id = current_setting('vessel.id', true))
+        ORDER BY id ASC;
+-- Description
+COMMENT ON VIEW
+    api.eventlogs_view
+    IS 'Event logs view';
+
+-- CRON for new video notification
+DROP FUNCTION IF EXISTS public.cron_process_new_video_fn;
+CREATE FUNCTION public.cron_process_new_video_fn() RETURNS void AS $$
+declare
+    process_rec record;
+    metadata_rec record;
+    video_settings jsonb;
+    user_settings jsonb;
+begin
+    -- Check for new event notification pending update
+    RAISE NOTICE 'cron_process_new_video_fn';
+    FOR process_rec in
+        SELECT * FROM process_queue
+            WHERE channel = 'new_video'
+                AND processed IS NULL
+            ORDER BY stored ASC
+    LOOP
+        RAISE NOTICE '-> cron_process_new_video_fn for [%]', process_rec.payload;
+        SELECT * INTO metadata_rec
+            FROM api.metadata
+            WHERE vessel_id = process_rec.ref_id::TEXT;
+
+        IF metadata_rec.vessel_id IS NULL OR metadata_rec.vessel_id = '' THEN
+            RAISE WARNING '-> cron_process_new_video_fn invalid metadata record vessel_id %', vessel_id;
+            RAISE EXCEPTION 'Invalid metadata'
+                USING HINT = 'Unknown vessel_id';
+            RETURN;
+        END IF;
+        PERFORM set_config('vessel.id', metadata_rec.vessel_id, false);
+        RAISE DEBUG '-> DEBUG cron_process_new_video_fn vessel_id %', current_setting('vessel.id', false);
+        -- Prepare notification, gather user settings
+        SELECT json_build_object('video_link', CONCAT('https://videos.openplotter.cloud/', process_rec.payload)) into video_settings;
+        -- Gather user settings
+        user_settings := get_user_settings_from_vesselid_fn(metadata_rec.vessel_id::TEXT);
+        SELECT user_settings::JSONB || video_settings::JSONB into user_settings;
+        RAISE DEBUG '-> DEBUG cron_process_new_video_fn get_user_settings_from_vesselid_fn [%]', user_settings;
+        -- Send notification
+        PERFORM send_notification_fn('video_ready'::TEXT, user_settings::JSONB);
+        -- update process_queue entry as processed
+        UPDATE process_queue
+            SET
+                processed = NOW()
+            WHERE id = process_rec.id;
+        RAISE NOTICE '-> cron_process_new_video_fn updated process_queue table [%]', process_rec.id;
+    END LOOP;
+END;
+$$ language plpgsql;
+-- Description
+COMMENT ON FUNCTION
+    public.cron_process_new_video_fn
+    IS 'init by pg_cron to check for new video event pending notifications, if so perform process_notification_queue_fn';
+
+-- Add support for video link for maplapse
+DROP FUNCTION IF EXISTS public.send_pushover_py_fn;
+CREATE OR REPLACE FUNCTION public.send_pushover_py_fn(IN message_type TEXT, IN _user JSONB, IN app JSONB) RETURNS void
+AS $send_pushover_py$
+    """
+    https://pushover.net/api#messages
+    Send a notification to a pushover user
+    """
+    import requests
+
+    # Use the shared cache to avoid preparing the email metadata
+    if message_type in SD:
+        plan = SD[message_type]
+    # A prepared statement from Python
+    else:
+        plan = plpy.prepare("SELECT * FROM email_templates WHERE name = $1", ["text"])
+        SD[message_type] = plan
+
+    # Execute the statement with the message_type param and limit to 1 result
+    rv = plpy.execute(plan, [message_type], 1)
+    pushover_title = rv[0]['pushover_title']
+    pushover_message = rv[0]['pushover_message']
+
+    # Replace fields using input jsonb obj
+    if 'logbook_name' in _user and _user['logbook_name']:
+        pushover_message = pushover_message.replace('__LOGBOOK_NAME__', _user['logbook_name'])
+    if 'logbook_link' in _user and _user['logbook_link']:
+        pushover_message = pushover_message.replace('__LOGBOOK_LINK__', str(_user['logbook_link']))
+    if 'video_link' in _user and _user['video_link']:
+        pushover_message = pushover_message.replace('__VIDEO_LINK__', str( _user['video_link']))
+    if 'recipient' in _user and _user['recipient']:
+        pushover_message = pushover_message.replace('__RECIPIENT__', _user['recipient'])
+    if 'boat' in _user and _user['boat']:
+        pushover_message = pushover_message.replace('__BOAT__', _user['boat'])
+    if 'badge' in _user and _user['badge']:
+        pushover_message = pushover_message.replace('__BADGE_NAME__', _user['badge'])
+    if 'alert' in _user and _user['alert']:
+        pushover_message = pushover_message.replace('__ALERT__', _user['alert'])
+
+    if 'app.url' in app and app['app.url']:
+        pushover_message = pushover_message.replace('__APP_URL__', app['app.url'])
+
+    pushover_token = None
+    if 'app.pushover_app_token' in app and app['app.pushover_app_token']:
+        pushover_token = app['app.pushover_app_token']
+    else:
+        plpy.error('Error no pushover token defined, check app settings')
+        return None
+    pushover_user = None
+    if 'pushover_user_key' in _user and _user['pushover_user_key']:
+        pushover_user = _user['pushover_user_key']
+    else:
+        plpy.error('Error no pushover user token defined, check user settings')
+        return None
+
+    if message_type == 'logbook' and 'logbook_img' in _user and _user['logbook_img']:
+        # Send notification with gis image logbook as attachment
+        img_url = 'https://gis.openplotter.cloud/{}'.format(str(_user['logbook_img']))
+        response = requests.get(img_url, stream=True)
+        if response.status_code == 200:
+            r = requests.post("https://api.pushover.net/1/messages.json", data = {
+                "token": pushover_token,
+                "user": pushover_user,
+                "title": pushover_title,
+                "message": pushover_message
+            }, files = {
+                "attachment": (str(_user['logbook_img']), response.raw.data, "image/png")
+            })
+    else:
+        r = requests.post("https://api.pushover.net/1/messages.json", data = {
+                "token": pushover_token,
+                "user": pushover_user,
+                "title": pushover_title,
+                "message": pushover_message
+        })
+
+    #print(r.text)
+    # Return ?? or None if not found
+    #plpy.notice('Sent pushover successfully to [{}] [{}]'.format(r.text, r.status_code))
+    if r.status_code == 200:
+        plpy.notice('Sent pushover successfully to [{}] [{}] [{}]'.format(pushover_user, pushover_title, r.text))
+    else:
+        plpy.error('Failed to send pushover')
+    return None
+$send_pushover_py$ TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.send_pushover_py_fn
+    IS 'Send pushover notification using plpython3u';
+
+-- Add support for video link for maplapse
+DROP FUNCTION IF EXISTS public.send_telegram_py_fn;
+CREATE OR REPLACE FUNCTION public.send_telegram_py_fn(IN message_type TEXT, IN _user JSONB, IN app JSONB) RETURNS void
+AS $send_telegram_py$
+    """
+    https://core.telegram.org/bots/api#sendmessage
+    Send a message to a telegram user or group specified on chatId
+    chat_id must be a number!
+    """
+    import requests
+    import json
+
+    # Use the shared cache to avoid preparing the email metadata
+    if message_type in SD:
+        plan = SD[message_type]
+    # A prepared statement from Python
+    else:
+        plan = plpy.prepare("SELECT * FROM email_templates WHERE name = $1", ["text"])
+        SD[message_type] = plan
+
+    # Execute the statement with the message_type param and limit to 1 result
+    rv = plpy.execute(plan, [message_type], 1)
+    telegram_title = rv[0]['pushover_title']
+    telegram_message = rv[0]['pushover_message']
+
+    # Replace fields using input jsonb obj
+    if 'logbook_name' in _user and _user['logbook_name']:
+        telegram_message = telegram_message.replace('__LOGBOOK_NAME__', _user['logbook_name'])
+    if 'logbook_link' in _user and _user['logbook_link']:
+        telegram_message = telegram_message.replace('__LOGBOOK_LINK__', str(_user['logbook_link']))
+    if 'video_link' in _user and _user['video_link']:
+        telegram_message = telegram_message.replace('__VIDEO_LINK__', str( _user['video_link']))
+    if 'recipient' in _user and _user['recipient']:
+        telegram_message = telegram_message.replace('__RECIPIENT__', _user['recipient'])
+    if 'boat' in _user and _user['boat']:
+        telegram_message = telegram_message.replace('__BOAT__', _user['boat'])
+    if 'badge' in _user and _user['badge']:
+        telegram_message = telegram_message.replace('__BADGE_NAME__', _user['badge'])
+    if 'alert' in _user and _user['alert']:
+        telegram_message = telegram_message.replace('__ALERT__', _user['alert'])
+
+    if 'app.url' in app and app['app.url']:
+        telegram_message = telegram_message.replace('__APP_URL__', app['app.url'])
+
+    telegram_token = None
+    if 'app.telegram_bot_token' in app and app['app.telegram_bot_token']:
+        telegram_token = app['app.telegram_bot_token']
+    else:
+        plpy.error('Error no telegram token defined, check app settings')
+        return None
+    telegram_chat_id = None
+    if 'telegram_chat_id' in _user and _user['telegram_chat_id']:
+        telegram_chat_id = _user['telegram_chat_id']
+    else:
+        plpy.error('Error no telegram user token defined, check user settings')
+        return None
+
+    # sendMessage via requests
+    headers = {'Content-Type': 'application/json',
+            'Proxy-Authorization': 'Basic base64'}
+    data_dict = {'chat_id': telegram_chat_id,
+                'text': telegram_message,
+                'parse_mode': 'HTML',
+                'disable_notification': False}
+    data = json.dumps(data_dict)
+    url = f'https://api.telegram.org/bot{telegram_token}/sendMessage'
+    r = requests.post(url, data=data, headers=headers)
+    if message_type == 'logbook' and 'logbook_img' in _user and _user['logbook_img']:
+        # Send gis image logbook
+        # https://core.telegram.org/bots/api#sendphoto
+        data_dict['photo'] = 'https://gis.openplotter.cloud/{}'.format(str(_user['logbook_img']))
+        del data_dict['text']
+        data = json.dumps(data_dict)
+        url = f'https://api.telegram.org/bot{telegram_token}/sendPhoto'
+        r = requests.post(url, data=data, headers=headers)
+
+    #print(r.text)
+    # Return something boolean?
+    #plpy.notice('Sent telegram successfully to [{}] [{}]'.format(r.text, r.status_code))
+    if r.status_code == 200:
+        plpy.notice('Sent telegram successfully to [{}] [{}] [{}]'.format(telegram_chat_id, telegram_title, r.text))
+    else:
+        plpy.error('Failed to send telegram')
+    return None
+$send_telegram_py$ TRANSFORM FOR TYPE jsonb LANGUAGE plpython3u;
+-- Description
+COMMENT ON FUNCTION
+    public.send_telegram_py_fn
+    IS 'Send a message to a telegram user or group specified on chatId using plpython3u';
+
+-- Add maplapse video record in queue
+DROP FUNCTION IF EXISTS api.maplapse_record_fn;
+CREATE OR REPLACE FUNCTION api.maplapse_record_fn(IN maplapse TEXT) RETURNS BOOLEAN
+AS $maplapse_record$
+    BEGIN
+        -- payload: 'Bromera,?start_log=8430&end_log=8491&height=100vh'
+        IF maplapse ~ '^(\w+)\,\?(start_log=\d+).*$' then
+            INSERT INTO process_queue (channel, payload, stored, ref_id)
+                VALUES ('maplapse_video', maplapse, NOW(), current_setting('vessel.id', true));
+            RETURN True;
+        ELSE
+            RETURN False;
+        END IF;
+    END;
+$maplapse_record$ language plpgsql security definer;
+-- Description
+COMMENT ON FUNCTION
+    api.maplapse_record_fn
+    IS 'Add maplapse video record in queue';
+
+CREATE ROLE maplapse_role WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS NOREPLICATION CONNECTION LIMIT 10 LOGIN PASSWORD 'mysecretpassword';
+COMMENT ON ROLE maplapse_role IS
+    'Role use by maplapse external cronjob to connect and lookup the process_queue table.';
+GRANT USAGE ON SCHEMA public TO maplapse_role;
+GRANT SELECT,UPDATE,INSERT ON TABLE public.process_queue TO maplapse_role;
+GRANT USAGE, SELECT ON SEQUENCE public.process_queue_id_seq TO maplapse_role;
+-- Allow maplapse_role to select,update,insert on tbl process_queue
+CREATE POLICY public_maplapse_role ON public.process_queue TO maplapse_role
+    USING (true)
+    WITH CHECK (true);
+
+-- Allow to execute fn for user_role and grafana
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA api TO user_role;
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA api TO grafana;
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO user_role;
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO grafana;
+GRANT SELECT ON TABLE api.eventlogs_view TO user_role;
+
+-- Update grafana role SQl connection to 30
+ALTER ROLE grafana WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS NOREPLICATION CONNECTION LIMIT 30 LOGIN;
+
+-- Alter moorages table with default duration of 0.
+ALTER TABLE api.moorages ALTER COLUMN stay_duration SET DEFAULT 'PT0S';
+-- Update moorage_view to default with duration of 0
+DROP VIEW IF EXISTS api.moorage_view;
+CREATE OR REPLACE VIEW api.moorage_view WITH (security_invoker=true,security_barrier=true) AS -- TODO
+    SELECT id,
+        m.name AS Name,
+        sa.description AS Default_Stay,
+        sa.stay_code AS Default_Stay_Id,
+        m.home_flag AS Home,
+        EXTRACT(DAY FROM justify_hours ( COALESCE(m.stay_duration, 'PT0S') )) AS Total_Stay,
+        COALESCE(m.stay_duration, 'PT0S') AS Total_Duration,
+        m.reference_count AS Arrivals_Departures,
+        m.notes
+--        m.geog
+    FROM api.moorages m, api.stays_at sa
+-- m.stay_duration is only process on a stay
+-- default with duration of 0sec
+    WHERE geog IS NOT NULL
+        AND m.stay_code = sa.stay_code;
+-- Description
+COMMENT ON VIEW
+    api.moorage_view
+    IS 'Moorage details web view';
+
+-- Update version
+UPDATE public.app_settings
+	SET value='0.7.4'
+	WHERE "name"='app.version';
+
+\c postgres
+
+-- Create a every 7 minutes for cron_process_post_logbook_fn
+SELECT cron.schedule('cron_post_logbook', '*/7 * * * *', 'select public.cron_process_post_logbook_fn()');
+UPDATE cron.job SET database = 'signalk' where jobname = 'cron_post_logbook';
+-- Create a every 15 minutes for cron_process_post_logbook_fn
+SELECT cron.schedule('cron_new_video', '*/15 * * * *', 'select public.cron_process_new_video_fn()');
+UPDATE cron.job SET database = 'signalk' where jobname = 'cron_new_video';

initdb/99env.sh

@@ -17,6 +17,8 @@ INSERT INTO app_settings (name, value) VALUES
         ('app.pushover_app_token', '${PGSAIL_PUSHOVER_APP_TOKEN}'),
         ('app.pushover_app_url', '${PGSAIL_PUSHOVER_APP_URL}'),
         ('app.telegram_bot_token', '${PGSAIL_TELEGRAM_BOT_TOKEN}'),
+        ('app.grafana_admin_uri', '${PGSAIL_GRAFANA_ADMIN_URI}'),
+        ('app.keycloak_uri', '${PGSAIL_KEYCLOAK_URI}'),
         ('app.url', '${PGSAIL_APP_URL}'),
         ('app.version', '${PGSAIL_VERSION}');
 -- Update comment with version
@@ -26,3 +28,5 @@ ALTER ROLE authenticator WITH PASSWORD '${PGSAIL_AUTHENTICATOR_PASSWORD}';
 ALTER ROLE grafana WITH PASSWORD '${PGSAIL_GRAFANA_PASSWORD}';
 ALTER ROLE grafana_auth WITH PASSWORD '${PGSAIL_GRAFANA_AUTH_PASSWORD}';
 END
+
+curl -s -XPOST -Hx-pgsail:${PGSAIL_VERSION} https://api.openplotter.cloud/rpc/telemetry_fn

initdb/PGSAIL_VERSION

@@ -1 +1 @@
-0.2.1
+0.7.4

pgadmin_servers.json

@@ -0,0 +1,13 @@
+{
+  "Servers": {
+    "dev": {
+      "Name": "PostgSail dev db",
+      "Group": "Servers",
+      "Port": 5432,
+      "Host": "db",
+      "SSLMode": "prefer",
+      "MaintenanceDB": "postgres",
+      "Username": "postgres"
+    }
+  }
+}

tests/Dockerfile

@@ -0,0 +1,7 @@
+FROM node:lts
+
+ENV DEBIAN_FRONTEND=noninteractive
+# Install and update the system
+RUN apt-get -q update && apt-get -qy upgrade && apt-get -qy install postgresql-client
+# Clean up APT when done.
+RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

tests/README.md

@@ -0,0 +1,18 @@
+# PostgSail Unit Tests
+The Unit Tests allow to automatically validate api workflow.
+
+## A global overview
+Based on `mocha` & `psql`
+
+## get started
+```bash
+$ npm i
+$ alias mocha="./node_modules/.bin/mocha"
+$ bash tests.sh
+```
+
+## docker
+```bash
+$ docker-compose up -d db && sleep 15 && docker-compose up -d api && sleep 5
+$ docker-compose -f docker-compose.dev.yml -f docker-compose.yml up tests
+```

tests/index.js

@@ -0,0 +1,826 @@
+'use strict';
+/*
+* Unit test #1
+* Create 2 users and 2 associate vessel with metrics
+*
+* process.env.PGSAIL_API_URI = from inside the docker 
+*
+* npm install supertest should mocha mochawesome moment
+* alias mocha="./node_modules/mocha/bin/_mocha"
+* mocha index.js --reporter mochawesome --reporter-options reportDir=/mnt/postgsail/,reportFilename=report_api.html
+*
+*/
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+const supertest = require("supertest");
+// Deprecated
+const should = require("should");
+//const chai = require("chai");
+//const should = chai.should();
+let request = null;
+let user_jwt = null;
+let vessel_jwt = null;
+var moment = require('moment');
+const metrics_kapla = require('./metrics_sample_kapla.json');
+const metrics_aava = require('./metrics_sample_aava.json');
+
+const fs = require('fs');
+
+
+// CNAMEs Array
+[
+  
+  { cname: process.env.PGSAIL_API_URI, name: "PostgSail unit test kapla",
+    signin: { email: 'demo+kapla@openplotter.cloud', pass: 'test', firstname:'First_kapla', lastname:'Last_kapla'},
+    login: { email: 'demo+kapla@openplotter.cloud', pass: 'test'},
+    vessel: { vessel_email: "demo+kapla@openplotter.cloud", vessel_mmsi: "test", vessel_name: " kapla "},
+    preferences: { key: '{email_notifications}', value: false }, /* Disable email_notifications */
+    vessel_metadata: {
+            name: "kapla",
+            mmsi: "123456789",
+            client_id: "vessels.urn:mrn:signalk:uuid:5b4f7543-7153-4840-b139-761310b242fd",
+            length: "12",
+            beam: "10",
+            height: "24",
+            ship_type: "36",
+            plugin_version: "0.0.1",
+            signalk_version: "signalk_version",
+            time: moment.utc().subtract(69, 'minutes').format()
+            /* To trigger monitor_offline quickly */
+          },
+    vessel_metrics: metrics_kapla,
+    user_tables: [
+        { url: '/stays', res_body_length: 3},
+        // not processed yet, { url: '/moorages', res_body_length: 2},
+        { url: '/logbook', res_body_length: 2},
+        { url: '/metadata', res_body_length: 1}
+    ],
+    user_views: [
+        // not processed yet, { url: '/stays_view', res_body_length: 1},
+        // not processed yet, { url: '/moorages_view', res_body_length: 1},
+        { url: '/logs_view', res_body_length: 0},
+        { url: '/log_view', res_body_length: 2},
+        //{ url: '/stats_view', res_body_length: 1},
+        { url: '/vessels_view', res_body_length: 1},
+    ],
+    user_patchs: [
+      { url: '/logbook?id=eq.1',
+        patch: {
+              name: "patch log name",
+              notes: "new log note"
+            },
+      },
+      { url: '/stays?id=eq.1',
+        patch: {
+              name: "patch stay name",
+              stay_code: 2,
+              notes: "new stay note"
+            },
+      },
+      /* not processed yet, { url: '/moorages?id=eq.1',
+        patch: {
+              name: "patch moorage name",
+              home_flag: true,
+              stay_code: 2,
+              notes: "new moorage note"
+            },
+      }
+      */
+    ],
+    user_fn: [
+      { url: '/rpc/timelapse_fn',
+        payload: {
+              start_log: 1
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_geojson_fn',
+        payload: {
+              _id: 1
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_gpx_fn',
+        payload: {
+              _id: 1
+            },
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/vessel_fn',
+        payload: null,
+        res: {
+          obj_name: 'vessel'
+        }
+      },
+      { url: '/rpc/settings_fn',
+        payload: null,
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/versions_fn',
+        payload: null,
+        res: {
+          obj_name: 'versions'
+        }
+      }
+    ],
+    otp_fn: [
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+kapla@openplotter.cloud' },
+        res: {
+          otp: 0
+        }
+      },
+      { url: '/rpc/email_fn',
+        payload: { token: null },
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+kapla@openplotter.cloud' },
+        res: {
+          otp: 0
+        }
+      },
+      { url: '/rpc/pushover_fn',
+        payload: { token: null, pushover_user_key: '1234567890azerty!'},
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+kapla@openplotter.cloud' },
+        res: {
+          otp: 0
+        }
+      },
+      { url: '/rpc/telegram_fn',
+        payload: { token: null, telegram_obj: {"chat": {"id": 1234567890, "type": "private", "title": null, "all_members_are_administrators": null}, "date": "NOW", "from": {"id": 1234567890, "is_bot": false, "first_name": "Kapla", "language_code": "en"}} },
+        res: {
+            obj_name: 'settings'
+          }
+      }
+    ]
+  },
+  { cname: process.env.PGSAIL_API_URI, name: "PostgSail unit test, aava",
+    signin: { email: 'demo+aava@openplotter.cloud', pass: 'test', firstname:'first_aava', lastname:'last_aava'},
+    login: { email: 'demo+aava@openplotter.cloud', pass: 'test'},
+    vessel: { vessel_email: "demo+aava@openplotter.cloud", vessel_mmsi: "787654321", vessel_name: " aava "},
+    preferences: { key: '{email_notifications}', value: false }, /* Disable email_notifications */
+    vessel_metadata: {
+            name: "aava",
+            mmsi: "787654321",
+            client_id: "vessels.urn:mrn:imo:mmsi:787654321",
+            length: "12",
+            beam: "10",
+            height: "24",
+            ship_type: "37",
+            plugin_version: "1.0.2",
+            signalk_version: "1.20.0",
+            time: moment().subtract(69, 'minutes').format()
+          },
+    vessel_metrics: metrics_aava,
+    user_tables: [
+        { url: '/stays', res_body_length: 2},
+        // not processed yet, { url: '/moorages', res_body_length: 2},
+        { url: '/logbook', res_body_length: 1},
+        { url: '/metadata', res_body_length: 1}
+    ],
+    user_views: [
+        // not processed yet, { url: '/stays_view', res_body_length: 1},
+        // not processed yet, { url: '/moorages_view', res_body_length: 1},
+        { url: '/logs_view', res_body_length: 0},
+        { url: '/log_view', res_body_length: 1},
+        //{ url: '/stats_view', res_body_length: 1},
+        { url: '/vessels_view', res_body_length: 1},
+    ],
+    user_patchs: [
+      { url: '/logbook?id=eq.3',
+        patch: {
+              name: "patch log name",
+              notes: "new log note"
+            },
+      },
+      { url: '/stays?id=eq.4',
+        patch: {
+              name: "patch stay name",
+              stay_code: 2,
+              notes: "new stay note"
+            },
+      },
+      /* not processed yet, { url: '/moorages?id=eq.1',
+        patch: {
+              name: "patch moorage name",
+              home_flag: true,
+              stay_code: 2,
+              notes: "new moorage note"
+            },
+      }
+      */
+    ],
+    user_fn: [
+      { url: '/rpc/timelapse_fn',
+        payload: {
+              start_log: 3
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_geojson_fn',
+        payload: {
+              _id: 3
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_gpx_fn',
+        payload: {
+              _id: 3
+            },
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/vessel_fn',
+        payload: null,
+        res: {
+          obj_name: 'vessel'
+        }
+      },
+      { url: '/rpc/settings_fn',
+        payload: null,
+        res: {
+          obj_name: 'settings'
+        }
+      }
+    ],
+    otp_fn: [
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+aava@openplotter.cloud' },
+        res: {
+          otp: 0
+        }
+      },
+      { url: '/rpc/email_fn',
+        payload: { token: null },
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+aava@openplotter.cloud' },
+        res: {
+          otp: 0
+        }
+      },
+      { url: '/rpc/pushover_fn',
+        payload: { token: null, pushover_user_key: '0987654321qwerty!'},
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+aava@openplotter.cloud' },
+        res: {
+          otp: 0
+        }
+      },
+      { url: '/rpc/telegram_fn',
+        payload: { token: null, telegram_obj: {"chat": {"id": 9876543210, "type": "private", "title": null, "all_members_are_administrators": null}, "date": "NOW", "from": {"id": 9876543210, "is_bot": false, "first_name": "Aava", "language_code": "en"}} },
+        res: {
+          obj_name: 'settings'
+        }
+      },
+    ]
+  }
+].forEach( function(test){
+
+//console.log(`${test.cname}`);
+describe(`${test.name}`, function(){
+request = supertest.agent(test.cname);
+request.set('User-Agent', 'PostgSail unit tests');
+
+  describe("OpenAPI description", function(){
+
+    it('/', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/')
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          should.exist(res.body.paths['/rpc/signup']);
+          should.exist(res.body.paths['/rpc/login']);
+          should.exist(res.body.paths['/rpc/reset']);
+          should.exist(res.body.paths['/rpc/recover']);
+          //should.exist(res.body.paths['/rpc/generate_otp_fn']);
+          should.exist(res.body.paths['/rpc/pushover_fn']);
+          should.exist(res.body.paths['/rpc/telegram_fn']);
+          should.exist(res.body.paths['/rpc/telegram']);
+          done(err);
+        });
+      });
+
+  }); // OpenAPI description
+
+  describe("Get JWT user_role", function(){
+
+      it('/rpc/signup return user_role jwt token', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/signup')
+            .send(test.signin)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body.token);
+              user_jwt = res.body.token;
+              should.exist(user_jwt);
+              done(err);
+            });
+      });
+
+      it('/rpc/login return user_role jwt token', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/login')
+            .send(test.login)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body.token);
+              //res.body.token.should.match(user_jwt);
+              console.log(user_jwt);
+              should.exist(user_jwt);
+              done(err);
+            });
+      }); 
+
+  }); // JWT user_role
+
+  describe("OpenAPI with JWT user_role", function(){
+
+    it('/', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/')
+        .set('Authorization', `Bearer ${user_jwt}`)
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          // Functions
+          should.exist(res.body.paths['/rpc/register_vessel']);
+          should.exist(res.body.paths['/rpc/update_user_preferences_fn']);
+          should.exist(res.body.paths['/rpc/settings_fn']);
+          should.exist(res.body.paths['/rpc/versions_fn']);
+          // Tables
+          should.exist(res.body.paths['/metadata']);
+          should.exist(res.body.paths['/metrics']);
+          should.exist(res.body.paths['/logbook']);
+          should.exist(res.body.paths['/stays']);
+          should.exist(res.body.paths['/moorages']);
+          // Views
+          should.exist(res.body.paths['/logs_view']);
+          should.exist(res.body.paths['/moorages_view']);
+          should.exist(res.body.paths['/stays_view']);
+          should.exist(res.body.paths['/vessels_view']);
+          //should.exist(res.body.paths['/stats_view']);
+          should.exist(res.body.paths['/monitoring_view']);
+          done(err);
+        });
+    });
+
+  }); // OpenAPI JWT user_role
+
+  describe("Set preferences email_notifications, JWT user_role", function(){
+
+      it('/rpc/update_user_preferences_fn return true', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/update_user_preferences_fn')
+            .send(test.preferences)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //console.log(res.text);
+              should.exist(res.text);
+              res.text.should.match('true');
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get versions, JWT user_role", function(){
+
+      it('/rpc/versions_fn return json', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get('/rpc/versions_fn')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //console.log(res.text);
+              should.exist(res.body.api_version);
+              should.exist(res.body.sys_version);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get JWT vessel_role from user_role", function(){
+
+      it('/rpc/register_vessel return vessel_role jwt token', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/register_vessel')
+            .send(test.vessel)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body.token);
+              vessel_jwt = res.body.token;
+              console.log(vessel_jwt);
+              should.exist(vessel_jwt);
+              // Save vessel JWT token for later use.
+              fs.writeFile(`vessel_jwt_${test.vessel.vessel_name}.txt`, vessel_jwt, (err) => {
+                // In case of a error throw err.
+                if (err) throw err;
+              })
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("OpenAPI with JWT vessel_role", function(){
+
+    it('/', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/')
+        .set('Authorization', `Bearer ${vessel_jwt}`)
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          should.exist(res.body.paths['/metadata']);
+          should.exist(res.body.paths['/metrics']);
+          should.exist(res.body.paths['/logbook']);
+          should.exist(res.body.paths['/stays']);
+          should.exist(res.body.paths['/moorages']);
+          done(err);
+        });
+    });
+
+  }); // OpenAPI JWT vessel_role
+
+  describe("Get vessel details view, JWT user_role", function(){
+
+      it('/vessels_view return json', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get('/vessels_view')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              console.log(res.body);
+              //res.body.length.should.match(0);
+              res.body.length.should.match(1);
+              //res.body[0].last_contact.should.match('Never');
+              should.equal(res.body[0].last_contact, null);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get vessel details function, JWT user_role", function(){
+    // no metadata from vessel so error - unrecognized configuration parameter "vessel.client_id"
+      it('/rpc/vessel_fn return json', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get('/rpc/vessel_fn')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .end(function(err,res){
+              console.log(res.body)
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body);
+              //body = res.body;
+              //console.log(res.text);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Vessel POST metadata, JWT vessel_role", function(){
+
+    it('/metadata?on_conflict=vessel_id', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .post('/metadata?on_conflict=vessel_id')
+        .send(test.vessel_metadata)
+        .set('Authorization', `Bearer ${vessel_jwt}`)
+        .set('Accept', 'application/json')
+        .set('Content-Type', 'application/json')
+        .set('Prefer', 'return=headers-only,resolution=merge-duplicates')
+        .end(function(err,res){
+          res.status.should.equal(201);
+          //console.log(res.header);
+          should.exist(res.header['server']);
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          done(err);
+        });
+    });
+
+  }); // Vessel metadata JWT vessel_role
+
+  describe("Vessel POST metrics, JWT vessel_role", function(){
+
+    let data = [];
+    //console.log(vessel_metrics['metrics'][0]);
+    let i;
+    for (i = 0; i < test.vessel_metrics['metrics'].length; i++) {
+      data[i] = test.vessel_metrics['metrics'][i];
+      // Override time, -2h to allow to new data later without delay.
+      data[i]['time'] = moment.utc().subtract(2, 'hours').add(i, 'minutes').format();
+      // Override client_id
+      data[i]['client_id'] = test.vessel_metadata.client_id;
+    }
+    // The last entry are invalid and should be ignore.
+    // - Invalid status
+    // - Invalid speedoverground
+    // - Invalid time previous time is duplicate
+    // Force last valid entry to be back in time from previous, it should be ignore silently
+    data.at(-1).time = moment.utc(data.at(-3).time).subtract(1, 'minutes').format();
+    //console.log(data[0]);
+
+    it('/metrics?select=time', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .post('/metrics?select=time')
+        .send(data)
+        .set('Authorization', `Bearer ${vessel_jwt}`)
+        .set('Accept', 'application/json')
+        .set('Content-Type', 'application/json')
+        .set('Prefer', 'return=representation')
+        .end(function(err,res){
+          //console.log(res.body);
+          res.status.should.equal(201);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          should.exist(res.body);
+          res.body.length.should.match(test.vessel_metrics['metrics'].length-3);
+          done(err);
+        });
+    });
+
+  }); // Vessel POST metrics JWT vessel_role
+
+/*
+  describe("run_cron_jobs() JWT vessel_role", function(){
+
+    it('/rpc/run_cron_jobs', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/rpc/run_cron_jobs')
+        .set('Authorization', `Bearer ${vessel_jwt}`)
+        .set('Accept', 'application/json')
+        .set('Content-Type', 'application/json')
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          done();
+        });
+    });
+
+  }); // run_cron_jobs() JWT vessel_role
+*/
+
+  describe("Table endpoint, JWT user_role", function(){
+
+    test.user_tables.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get(`${subtest.url}`)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body);
+              res.body.length.should.match(subtest.res_body_length);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Table endpoint
+
+  describe("Views endpoint, JWT user_role", function(){
+
+    test.user_views.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get(`${subtest.url}`)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body);
+              res.body.length.should.match(subtest.res_body_length);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Views endpoint
+
+  describe("Patch endpoint, JWT user_role", function(){
+
+    test.user_patchs.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .patch(subtest.url)
+            .send(subtest.patch)
+            .set('Content-Type', 'application/json')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(204);
+              should.exist(res.header['server']);
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Patch endpoint
+
+  describe("Function endpoint, JWT user_role", function(){
+
+    test.user_fn.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post(subtest.url)
+            .send(subtest.payload)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //should.exist(res.body);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Function endpoint
+
+  /*
+  describe("Function OTP endpoint, JWT user_role", function(){
+
+    let otp = null;
+    test.otp_fn.forEach(function (subtest) {
+      otp = null;
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res}`);
+          if (otp) {
+            subtest.payload.token = otp;
+          }
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post(subtest.url)
+            .send(subtest.payload)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              console.log(res.body);
+              should.exist(res.body);
+              if (subtest.url == '/rpc/generate_otp_fn') {
+                otp = res.body;
+              } else {
+                res.text.should.match('true');
+                otp = null;
+              }              
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Function OTP endpoint
+  */
+
+}); // OpenAPI description
+
+}); // CNAMEs Array

tests/index2.js

@@ -0,0 +1,645 @@
+'use strict';
+/*
+* Unit test #2, additional aava sample vessel metrics
+*
+* process.env.PGSAIL_API_URI = from inside the docker 
+*
+* npm install supertest should mocha mochawesome moment
+* alias mocha="./node_modules/mocha/bin/_mocha"
+* mocha index.js --reporter mochawesome --reporter-options reportDir=/mnt/postgsail/,reportFilename=report_api.html
+*
+*/
+
+const supertest = require("supertest");
+const should = require("should");
+let request = null;
+let user_jwt = null;
+let vessel_jwt = null;
+var moment = require('moment');
+const metrics_simulator = require('./metrics_sample_simulator.json');
+
+// CNAMEs Array
+[
+  { cname: process.env.PGSAIL_API_URI, name: "PostgSail unit test 2, aava",
+    signin: { email: 'demo+aava@openplotter.cloud', pass: 'test', firstname:'first_aava', lastname:'last_aava'},
+    login: { email: 'demo+aava@openplotter.cloud', pass: 'test'},
+    vessel: { vessel_email: "demo+aava@openplotter.cloud", vessel_mmsi: "787654321", vessel_name: "aava"},
+    preferences: { key: '{email_notifications}', value: false }, /* Disable email_notifications */
+    vessel_metadata: {
+            name: "aava",
+            mmsi: "787654321",
+            client_id: "vessels.urn:mrn:imo:mmsi:787654321",
+            length: "12",
+            beam: "10",
+            height: "24",
+            ship_type: "37",
+            plugin_version: "1.0.2",
+            signalk_version: "1.20.0",
+            time: moment().subtract(69, 'minutes').format()
+          },
+    vessel_metrics: metrics_simulator,
+    user_tables: [
+      { url: '/stays', res_body_length: 3},
+      // not processed yet, { url: '/moorages', res_body_length: 2},
+      { url: '/logbook', res_body_length: 2},
+      { url: '/metadata', res_body_length: 1}
+    ],
+    user_views: [
+        // not processed yet, { url: '/stays_view', res_body_length: 1},
+        // not processed yet, { url: '/moorages_view', res_body_length: 1},
+        { url: '/logs_view', res_body_length: 1},
+        { url: '/log_view', res_body_length: 2},
+        //{ url: '/stats_view', res_body_length: 1},
+        { url: '/vessels_view', res_body_length: 1},
+    ],
+    user_patchs: [
+      { url: '/logbook?id=eq.4',
+        patch: {
+              name: "patch log name 2",
+              notes: "new log note 2"
+            },
+      },
+      { url: '/stays?id=eq.5',
+        patch: {
+              name: "patch stay name 2",
+              stay_code: 2,
+              notes: "new stay note 2"
+            },
+      },
+      /* not processed yet, { url: '/moorages?id=eq.1',
+        patch: {
+              name: "patch moorage name",
+              home_flag: true,
+              stay_code: 2,
+              notes: "new moorage note"
+            },
+      }
+      */
+    ],
+    user_fn: [
+      { url: '/rpc/timelapse_fn',
+        payload: {
+              start_log: 4
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_geojson_fn',
+        payload: {
+              _id: 4
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_gpx_fn',
+        payload: {
+              _id: 4
+            },
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/vessel_fn',
+        payload: null,
+        res: {
+          obj_name: 'vessel'
+        }
+      },
+      { url: '/rpc/settings_fn',
+        payload: null,
+        res: {
+          obj_name: 'settings'
+        }
+      }
+    ],
+    others_fn: [
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+aava@openplotter.cloud' },
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/pushover_fn',
+        // invalid key to avoid trigger notification
+        payload: { token: 'zxy', pushover_test_key: '987azerty#'},
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/update_user_preferences_fn',
+        //payload: { key: '{xyz}', value: '987azerty#'},
+        // invalid key to avoid trigger notification
+        payload: { key: '{telegram_test}', value: '{"id": 987654321, "is_bot": false, "first_name": "aaVa", "language_code": "en"}' },
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/bot',
+        payload: { email: 'demo+aava@openplotter.cloud', chat_id: 987654321},
+        res: {
+          obj_name: 'settings'
+        }
+      }
+    ]
+  }
+].forEach( function(test){
+
+//console.log(`${test.cname}`);
+describe(`${test.name}`, function(){
+request = supertest.agent(test.cname);
+request.set('User-Agent', 'PostgSail unit tests');
+
+  describe("OpenAPI description", function(){
+
+    it('/', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/')
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          should.exist(res.body.paths['/rpc/signup']);
+          should.exist(res.body.paths['/rpc/login']);
+          //should.exist(res.body.paths['/rpc/generate_otp_fn']);
+          should.exist(res.body.paths['/rpc/pushover_fn']);
+          should.exist(res.body.paths['/rpc/telegram_fn']);
+          //should.exist(res.body.paths['/rpc/bot']);
+          done(err);
+        });
+      });
+
+  }); // OpenAPI description
+
+  describe("Get JWT user_role", function(){
+
+      it('/rpc/signup return user_role jwt token', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/signup')
+            .send(test.signin)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body.token);
+              user_jwt = res.body.token;
+              should.exist(user_jwt);
+              done(err);
+            });
+      });
+
+      it('/rpc/login return user_role jwt token', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/login')
+            .send(test.login)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body.token);
+              //res.body.token.should.match(user_jwt);
+              console.log(user_jwt);
+              should.exist(user_jwt);
+              done(err);
+            });
+      }); 
+
+  }); // JWT user_role
+
+  describe("OpenAPI with JWT user_role", function(){
+
+    it('/', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/')
+        .set('Authorization', `Bearer ${user_jwt}`)
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          // Function
+          should.exist(res.body.paths['/rpc/register_vessel']);
+          should.exist(res.body.paths['/rpc/update_user_preferences_fn']);
+          should.exist(res.body.paths['/rpc/settings_fn']);
+          should.exist(res.body.paths['/rpc/versions_fn']);
+          // Tables
+          should.exist(res.body.paths['/metadata']);
+          should.exist(res.body.paths['/metrics']);
+          should.exist(res.body.paths['/logbook']);
+          should.exist(res.body.paths['/stays']);
+          should.exist(res.body.paths['/moorages']);
+          // Views
+          should.exist(res.body.paths['/logs_view']);
+          should.exist(res.body.paths['/moorages_view']);
+          should.exist(res.body.paths['/stays_view']);
+          should.exist(res.body.paths['/vessels_view']);
+//          should.exist(res.body.paths['/stats_view']);
+          should.exist(res.body.paths['/monitoring_view']);
+          done(err);
+        });
+    });
+
+  }); // OpenAPI JWT user_role
+
+  describe("Set preferences email_notifications, JWT user_role", function(){
+
+      it('/rpc/update_user_preferences_fn return true', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/update_user_preferences_fn')
+            .send(test.preferences)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //console.log(res.text);
+              should.exist(res.text);
+              res.text.should.match('true');
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get versions, JWT user_role", function(){
+
+      it('/rpc/versions_fn return json', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get('/rpc/versions_fn')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //console.log(res.text);
+              should.exist(res.body.api_version);
+              should.exist(res.body.sys_version);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get JWT vessel_role from user_role", function(){
+
+      it('/rpc/register_vessel return vessel_role jwt token', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/register_vessel')
+            .send(test.vessel)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body.token);
+              vessel_jwt = res.body.token;
+              console.log(vessel_jwt);
+              should.exist(vessel_jwt);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("OpenAPI with JWT vessel_role", function(){
+
+    it('/', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/')
+        .set('Authorization', `Bearer ${vessel_jwt}`)
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          should.exist(res.body.paths['/metadata']);
+          should.exist(res.body.paths['/metrics']);
+          should.exist(res.body.paths['/logbook']);
+          should.exist(res.body.paths['/stays']);
+          should.exist(res.body.paths['/moorages']);
+          done(err);
+        });
+    });
+
+  }); // OpenAPI JWT vessel_role
+
+  describe("Get vessel details view, JWT user_role", function(){
+
+      it('/vessels_view return json', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get('/vessels_view')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              console.log(res.body);
+              //res.body.length.should.match(0);
+              res.body.length.should.match(1);
+              //res.body[0].last_contact.should.match('Never');
+              should.exist(res.body[0].last_contact);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get vessel details function, JWT user_role", function(){
+
+      it('/rpc/vessel_fn return json', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/vessel_fn')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //should.exist(res.body);
+              //body = res.body;
+              console.log(res.text);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Vessel POST metadata, JWT vessel_role", function(){
+
+    it('/metadata', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .post('/metadata')
+        .send(test.vessel_metadata)
+        .set('Authorization', `Bearer ${vessel_jwt}`)
+        .set('Accept', 'application/json')
+        .set('Content-Type', 'application/json')
+        .set('Prefer', 'return=headers-only')
+        .end(function(err,res){
+          res.status.should.equal(201);
+          //console.log(res.header);
+          should.exist(res.header['server']);
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          done(err);
+        });
+    });
+
+  }); // Vessel metadata JWT vessel_role
+
+  describe("Vessel POST metrics, JWT vessel_role", function(){
+
+    let data = [];
+    //console.log(vessel_metrics['metrics'][0]);
+    let i;
+    for (i = 0; i < test.vessel_metrics['metrics'].length; i++) {
+      data[i] = test.vessel_metrics['metrics'][i];
+      // Override time, +1h because previous sample include 47 entry.
+      data[i]['time'] = moment().add(1, 'hour').add(i, 'minutes').format();
+      // Override client_id
+      data[i]['client_id'] = test.vessel_metadata.client_id;
+    }
+    console.log(data[0]);
+
+    it('/metrics?select=time', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .post('/metrics?select=time')
+        .send(data)
+        .set('Authorization', `Bearer ${vessel_jwt}`)
+        .set('Accept', 'application/json')
+        .set('Content-Type', 'application/json')
+        .set('Prefer', 'return=representation')
+        .end(function(err,res){
+          //console.log(res.body);
+          res.status.should.equal(201);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          should.exist(res.body);
+          res.body.length.should.match(test.vessel_metrics['metrics'].length);
+          done(err);
+        });
+    });
+
+  }); // Vessel POST metrics JWT vessel_role
+
+/*
+  describe("run_cron_jobs() JWT vessel_role", function(){
+
+    it('/rpc/run_cron_jobs', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/rpc/run_cron_jobs')
+        .set('Authorization', `Bearer ${vessel_jwt}`)
+        .set('Accept', 'application/json')
+        .set('Content-Type', 'application/json')
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          done();
+        });
+    });
+
+  }); // run_cron_jobs() JWT vessel_role
+*/
+
+  describe("Table endpoint, JWT user_role", function(){
+
+    test.user_tables.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get(`${subtest.url}`)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body);
+              res.body.length.should.match(subtest.res_body_length);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Table endpoint
+
+  describe("Views endpoint, JWT user_role", function(){
+
+    test.user_views.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get(`${subtest.url}`)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body);
+              res.body.length.should.match(subtest.res_body_length);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Views endpoint
+
+  describe("Patch endpoint, JWT user_role", function(){
+
+    test.user_patchs.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .patch(subtest.url)
+            .send(subtest.patch)
+            .set('Content-Type', 'application/json')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(204);
+              should.exist(res.header['server']);
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Patch endpoint
+
+  describe("Function user_fn endpoint, JWT user_role", function(){
+
+    test.user_fn.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post(subtest.url)
+            .send(subtest.payload)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //should.exist(res.body);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Function endpoint
+
+/*
+  describe("Function others endpoint, JWT user_role", function(){
+
+    let otp = null;
+    test.others_fn.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post(subtest.url)
+            .send(subtest.payload)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //console.log(res.body);
+              should.exist(res.body);
+              if (subtest.url == '/rpc/generate_otp_fn') {
+                otp = res.body.text();
+              }
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Function endpoint
+*/
+
+}); // OpenAPI description
+
+}); // CNAMEs Array

tests/index3.js

@@ -0,0 +1,836 @@
+'use strict';
+/*
+* Unit test #3, check post cron results, moorages, stays and stats
+*
+* process.env.PGSAIL_API_URI = from inside the docker 
+*
+* npm install supertest should mocha mochawesome moment
+* alias mocha="./node_modules/mocha/bin/_mocha"
+* mocha index.js --reporter mochawesome --reporter-options reportDir=/mnt/postgsail/,reportFilename=report_api.html
+*
+*/
+
+const supertest = require("supertest");
+// Deprecated
+const should = require("should");
+//const chai = require("chai");
+//const should = chai.should();
+let request = null;
+let user_jwt = null;
+let vessel_jwt = null;
+var moment = require('moment');
+
+// CNAMEs Array
+[
+  
+  { cname: process.env.PGSAIL_API_URI, name: "PostgSail unit test kapla",
+    signin: { email: 'demo+kapla@openplotter.cloud', pass: 'test', firstname:'First_kapla', lastname:'Last_kapla'},
+    login: { email: 'demo+kapla@openplotter.cloud', pass: 'test'},
+    vessel: { vessel_email: "demo+kapla@openplotter.cloud", vessel_mmsi: null, vessel_name: "kapla"},
+    preferences: { key: '{email_notifications}', value: false }, /* Disable email_notifications */
+    vessel_metadata: {
+            name: "kapla",
+            mmsi: "123456789",
+            client_id: "vessels.urn:mrn:imo:mmsi:123456789",
+            length: "12",
+            beam: "10",
+            height: "24",
+            ship_type: "36",
+            plugin_version: "0.0.1",
+            signalk_version: "1.12.0",
+            time: moment().subtract(69, 'minutes').format()
+            /* To trigger monitor_offline quickly */
+          },
+    user_tables: [
+        { url: '/stays', res_body_length: 3},
+        { url: '/moorages', res_body_length: 3},
+        { url: '/logbook', res_body_length: 2},
+        { url: '/metadata', res_body_length: 1}
+    ],
+    user_views: [
+        { url: '/stays_view', res_body_length: 2},
+        { url: '/moorages_view', res_body_length: 3},
+        { url: '/logs_view', res_body_length: 2},
+        { url: '/log_view', res_body_length: 2},
+        //{ url: '/stats_view', res_body_length: 1},
+        { url: '/vessels_view', res_body_length: 1},
+    ],
+    user_patchs: [
+      { url: '/logbook?id=eq.1',
+        patch: {
+              name: "patch log name 3",
+              notes: "new log note 3"
+            },
+      },
+      { url: '/stays?id=eq.1',
+        patch: {
+              name: "patch stay name 3",
+              stay_code: 2,
+              notes: "new stay note 3"
+            },
+      },
+      { url: '/moorages?id=eq.1',
+        patch: {
+              name: "patch moorage name 3",
+              home_flag: true,
+              stay_code: 2,
+              notes: "new moorage note 3"
+            },
+      }
+    ],
+    user_fn: [
+      { url: '/rpc/timelapse_fn',
+        payload: {
+              start_log: 2
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_geojson_fn',
+        payload: {
+              _id: 2
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_gpx_fn',
+        payload: {
+              _id: 2
+            },
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/export_logbook_kml_fn',
+        payload: {
+              _id: 2
+            },
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/export_moorages_geojson_fn',
+        payload: {},
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_moorages_gpx_fn',
+        payload: {},
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/find_log_from_moorage_fn',
+        payload: {
+          _id: 2
+        },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/find_log_to_moorage_fn',
+        payload: {
+          _id: 2
+        },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/vessel_fn',
+        payload: null,
+        res: {
+          obj_name: 'vessel'
+        }
+      },
+      { url: '/rpc/settings_fn',
+        payload: null,
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/versions_fn',
+        payload: null,
+        res: {
+          obj_name: 'versions'
+        }
+      },
+      { url: '/rpc/stats_logs_fn',
+        payload: {},
+        res: {
+          obj_name: 'stats'
+        }
+      },
+      { url: '/rpc/stats_logs_fn',
+        payload: {
+              start_date: '2022-01-01',
+              end_date: '2022-06-12'
+            },
+        res: {
+          obj_name: null
+        }
+      },
+    ],
+    email_otp_fn: [
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+kapla@openplotter.cloud' },
+        res: {
+          otp: 0
+        }
+      },
+      { url: '/rpc/email_fn',
+        //payload: { token: 'abc', pushover_user_key: '123qwerty!'},
+        // invalid key to avoid trigger notification
+        payload: { token: '123456' },
+        res: {
+          obj_name: 'settings'
+        }
+      }
+    ],
+    pushover_fn: [
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+kapla@openplotter.cloud' },
+        res: {
+          otp: 0
+        }
+      },
+      { url: '/rpc/pushover_fn',
+        //payload: { token: 'abc', pushover_user_key: '123qwerty!'},
+        // invalid key to avoid trigger notification
+        payload: { token: null, pushover_test_key: '123qwerty!'},
+        res: {
+          obj_name: 'settings'
+        }
+      }
+    ],
+    telegram_fn: [
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+kapla@openplotter.cloud' },
+        res: {
+          otp: 0
+        }
+      },
+      { url: '/rpc/telegram_fn',
+        //payload: { key: '{abc}', value: {"a": "1", "b": 2, "c": true}},
+        // invalid key to avoid trigger notification
+        payload: { token: null, telegram_test: '{"id": 123456789, "is_bot": false, "first_name": "kaplA", "language_code": "en"}' },
+        res: {
+          obj_name: 'settings'
+        }
+      }
+    ]
+  },
+  { cname: process.env.PGSAIL_API_URI, name: "PostgSail unit test, aava",
+    signin: {email: 'demo+aava@openplotter.cloud', pass: 'test', firstname:'first_aava', lastname:'last_aava'},
+    login: {email: 'demo+aava@openplotter.cloud', pass: 'test'},
+    vessel: {vessel_email: "demo+aava@openplotter.cloud", vessel_mmsi: null, vessel_name: "aava"},
+    preferences: { key: '{email_notifications}', value: false }, /* Disable email_notifications */
+    vessel_metadata: {
+            name: "aava",
+            mmsi: "787654321",
+            client_id: "vessels.urn:mrn:imo:mmsi:787654321",
+            length: "12",
+            beam: "10",
+            height: "24",
+            ship_type: "37",
+            plugin_version: "1.0.2",
+            signalk_version: "1.20.0",
+            time: moment().subtract(69, 'minutes').format()
+          },
+    user_tables: [
+        { url: '/stays', res_body_length: 3},
+        { url: '/moorages', res_body_length: 4},
+        { url: '/logbook', res_body_length: 2},
+        { url: '/metadata', res_body_length: 1}
+    ],
+    user_views: [
+        { url: '/stays_view', res_body_length: 2},
+        { url: '/moorages_view', res_body_length: 4},
+        { url: '/logs_view', res_body_length: 2},
+        { url: '/log_view', res_body_length: 2},
+        //{ url: '/stats_view', res_body_length: 1},
+        { url: '/vessels_view', res_body_length: 1},
+    ],
+    user_patchs: [
+      { url: '/logbook?id=eq.4',
+        patch: {
+              name: "patch log name 4",
+              notes: "new log note 4"
+            },
+      },
+      { url: '/stays?id=eq.4',
+        patch: {
+              name: "patch stay name 4",
+              stay_code: 2,
+              notes: "new stay note 4"
+            },
+      },
+      { url: '/moorages?id=eq.4',
+        patch: {
+              name: "patch moorage name",
+              home_flag: true,
+              stay_code: 2,
+              notes: "new moorage note"
+            },
+      }
+    ],
+    user_fn: [
+      { url: '/rpc/timelapse_fn',
+        payload: {
+              start_log: 4
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_geojson_fn',
+        payload: {
+              _id: 4
+            },
+        res: {
+          obj_name: 'geojson'
+        }
+      },
+      { url: '/rpc/export_logbook_gpx_fn',
+        payload: {
+              _id: 4
+            },
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/export_logbook_kml_fn',
+        payload: {
+              _id: 4
+            },
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/export_logbooks_gpx_fn',
+        payload: {
+            start_log: 3,
+            end_log: 4
+            },
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/export_logbooks_kml_fn',
+        payload: {
+            start_log: 3,
+            end_log: 4
+            },
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/export_moorages_geojson_fn',
+        payload: {},
+        res: {
+          geojson: { type: 'FeatureCollection', features: [ [Object], [Object] ] }
+        }
+      },
+      { url: '/rpc/export_moorages_gpx_fn',
+        payload: {},
+        res: {
+          obj_name: null
+        }
+      },
+      { url: '/rpc/find_log_from_moorage_fn',
+        payload: {
+          _id: 4
+        },
+        res: { geojson: { type: 'FeatureCollection', features: [ [Object] ] } }
+      },
+      { url: '/rpc/find_log_to_moorage_fn',
+        payload: {
+          _id: 4
+        },
+        res: { geojson: { type: 'FeatureCollection', features: [ [Object] ] } }
+      },
+      { url: '/rpc/vessel_fn',
+        payload: null,
+        res: {
+          vessel: {
+            beam: 10,
+            mmsi: 787654321,
+            name: 'aava',
+            height: 24,
+            length: 37,
+            alpha_2: null,
+            country: null,
+            geojson: { type: 'Feature', geometry: [Object], properties: [Object] },
+            ship_type: 'Pleasure Craft',
+            created_at: '2023-08-17T16:32:13',
+            last_contact: '2023-08-17T15:23:14'
+          }
+        }
+      },
+      { url: '/rpc/settings_fn',
+        payload: null,
+        res: {
+          settings: {
+            email: 'demo+aava@openplotter.cloud',
+            first: 'first_aava',
+            last: 'last_aava',
+            preferences: { badges: [Object], email_notifications: false },
+            created_at: '2023-08-17T16:32:12.701788',
+            username: 'F Last_Aava',
+            has_vessel: true
+          }
+        }
+      },
+      { url: '/rpc/stats_logs_fn',
+        payload: {},
+        res: { // Compare keys only
+          stats: {
+            count: 2,
+            max_speed: 7.1,
+            max_distance: 8.2365,
+            max_duration: '01:11:00',
+            max_speed_id: 3,
+            sum_duration: '01:54:00',
+            max_wind_speed: 44.2,
+            max_distance_id: 3,
+            max_wind_speed_id: 4
+          }
+        }
+      },
+      { url: '/rpc/stats_logs_fn',
+        payload: {
+              start_date: '2022-01-01',
+              end_date: '2022-06-12'
+            },
+        res: { stats: null }
+      },
+    ],
+    others_fn: [
+      { url: '/rpc/generate_otp_fn',
+        payload: { email: 'demo+aava@openplotter.cloud' },
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/pushover_fn',
+        // invalid key to avoid trigger notification
+        payload: { token: 'zxy', pushover_test_key: '987azerty#'},
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/update_user_preferences_fn',
+        //payload: { key: '{xyz}', value: '987azerty#'},
+        // invalid key to avoid trigger notification
+        payload: { key: '{telegram_test}', value: '{"id": 987654321, "is_bot": false, "first_name": "aaVa", "language_code": "en"}' },
+        res: {
+          obj_name: 'settings'
+        }
+      },
+      { url: '/rpc/bot',
+        payload: { email: 'demo+aava@openplotter.cloud', chat_id: 987654321},
+        res: {
+          obj_name: 'settings'
+        }
+      }
+    ]
+  }
+].forEach( function(test){
+
+//console.log(`${test.cname}`);
+describe(`${test.name}`, function(){
+request = supertest.agent(test.cname);
+request.set('User-Agent', 'PostgSail unit tests');
+
+  describe("OpenAPI description", function(){
+
+    it('/', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/')
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          should.exist(res.body.paths['/rpc/signup']);
+          should.exist(res.body.paths['/rpc/login']);
+          //should.exist(res.body.paths['/rpc/generate_otp_fn']);
+          should.exist(res.body.paths['/rpc/pushover_fn']);
+          should.exist(res.body.paths['/rpc/telegram_fn']);
+          //should.exist(res.body.paths['/rpc/bot']);
+          done(err);
+        });
+      });
+
+  }); // OpenAPI description
+
+  describe("Get JWT user_role", function(){
+
+      it('/rpc/signup return user_role jwt token', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/signup')
+            .send(test.signin)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body.token);
+              user_jwt = res.body.token;
+              should.exist(user_jwt);
+              done(err);
+            });
+      });
+
+      it('/rpc/login return user_role jwt token', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/login')
+            .send(test.login)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body.token);
+              //res.body.token.should.match(user_jwt);
+              //console.log(user_jwt);
+              should.exist(user_jwt);
+              done(err);
+            });
+      }); 
+
+  }); // JWT user_role
+
+  describe("OpenAPI with JWT user_role", function(){
+
+    it('/', function(done) {
+      request = supertest.agent(test.cname);
+      request
+        .get('/')
+        .set('Authorization', `Bearer ${user_jwt}`)
+        .end(function(err,res){
+          res.status.should.equal(200);
+          should.exist(res.header['content-type']);
+          should.exist(res.header['server']);
+          res.header['content-type'].should.match(new RegExp('json','g'));
+          res.header['server'].should.match(new RegExp('postgrest','g'));
+          // Function
+          should.exist(res.body.paths['/rpc/register_vessel']);
+          should.exist(res.body.paths['/rpc/update_user_preferences_fn']);
+          should.exist(res.body.paths['/rpc/settings_fn']);
+          should.exist(res.body.paths['/rpc/versions_fn']);
+          // Tables
+          should.exist(res.body.paths['/metadata']);
+          should.exist(res.body.paths['/metrics']);
+          should.exist(res.body.paths['/logbook']);
+          should.exist(res.body.paths['/stays']);
+          should.exist(res.body.paths['/moorages']);
+          // Views
+          should.exist(res.body.paths['/logs_view']);
+          should.exist(res.body.paths['/moorages_view']);
+          should.exist(res.body.paths['/stays_view']);
+          should.exist(res.body.paths['/vessels_view']);
+          //should.exist(res.body.paths['/stats_view']);
+          should.exist(res.body.paths['/monitoring_view']);
+          done(err);
+        });
+    });
+
+  }); // OpenAPI JWT user_role
+
+  describe("Set preferences email_notifications, JWT user_role", function(){
+
+      it('/rpc/update_user_preferences_fn return true', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/update_user_preferences_fn')
+            .send(test.preferences)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //console.log(res.text);
+              should.exist(res.text);
+              res.text.should.match('true');
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get versions, JWT user_role", function(){
+
+      it('/rpc/versions_fn return json', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get('/rpc/versions_fn')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //console.log(res.text);
+              should.exist(res.body.api_version);
+              should.exist(res.body.sys_version);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get JWT vessel_role from user_role", function(){
+
+      it('/rpc/register_vessel return vessel_role jwt token', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/register_vessel')
+            .send(test.vessel)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body.token);
+              vessel_jwt = res.body.token;
+              console.log(vessel_jwt);
+              should.exist(vessel_jwt);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get vessel details view, JWT user_role", function(){
+
+      it('/vessels_view return json', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get('/vessels_view')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              console.log(res.body);
+              //res.body.length.should.match(0);
+              res.body.length.should.match(1);
+              //res.body[0].last_contact.should.match('Never');
+              should.exist(res.body[0].last_contact);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Get vessel details function, JWT user_role", function(){
+
+      it('/rpc/vessel_fn return json', function(done) {
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post('/rpc/vessel_fn')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //should.exist(res.body);
+              //body = res.body;
+              console.log(res.text);
+              done(err);
+            });
+      });
+  }); // JWT user_role
+
+  describe("Table endpoint, JWT user_role", function(){
+
+    test.user_tables.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get(`${subtest.url}`)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              console.log(res.body);
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body);
+              res.body.length.should.match(subtest.res_body_length);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Table endpoint
+
+  describe("Views endpoint, JWT user_role", function(){
+
+    test.user_views.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .get(`${subtest.url}`)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              //console.log(res.body);
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              should.exist(res.body);
+              res.body.length.should.match(subtest.res_body_length);
+              console.log(res.body);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Views endpoint
+
+  describe("Patch endpoint, JWT user_role", function(){
+
+    test.user_patchs.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .patch(subtest.url)
+            .send(subtest.patch)
+            .set('Content-Type', 'application/json')
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(204);
+              should.exist(res.header['server']);
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              console.log(res.body);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Patch endpoint
+
+  describe("Function user_fn endpoint, JWT user_role", function(){
+
+    test.user_fn.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post(subtest.url)
+            .send(subtest.payload)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //should.exist(res.body);
+              console.log(res.body);
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Function endpoint
+
+/*
+  describe("Function others endpoint, JWT user_role", function(){
+
+    let otp = null;
+    test.others_fn.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post(subtest.url)
+            .send(subtest.payload)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //console.log(res.body);
+              should.exist(res.body);
+              if (subtest.url == '/rpc/generate_otp_fn') {
+                otp = res.body.text();
+              }
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Function endpoint
+*/
+
+}); // OpenAPI description
+
+}); // CNAMEs Array

tests/index4.js

@@ -0,0 +1,727 @@
+"use strict";
+/*
+ * Unit test #4
+ * OTP for email, Pushover, Telegram
+ *
+ * process.env.PGSAIL_API_URI = from inside the docker
+ *
+ * npm install supertest should mocha mochawesome moment
+ * alias mocha="./node_modules/mocha/bin/_mocha"
+ * mocha index4.js --reporter mochawesome --reporter-options reportDir=/mnt/postgsail/,reportFilename=report_api.html
+ *
+ */
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+const supertest = require("supertest");
+// Deprecated
+const should = require("should");
+//const chai = require("chai");
+//const should = chai.should();
+let request = null;
+let user_jwt = null;
+var moment = require("moment");
+
+// Users Array
+[
+  {
+    cname: process.env.PGSAIL_API_URI,
+    name: "PostgSail unit test kapla",
+    signin: {
+      email: "demo+kapla@openplotter.cloud",
+      pass: "test",
+      firstname: "First_kapla",
+      lastname: "Last_kapla",
+    },
+    login: { email: "demo+kapla@openplotter.cloud", pass: "test" },
+    preferences: { key: "{email_valid}", value: false },
+    email_otp: [
+      {
+        url: "/rpc/generate_otp_fn",
+        payload: { email: "demo+kapla@openplotter.cloud" },
+        res: {
+          otp: 0,
+        },
+      },
+      {
+        url: "/rpc/email_fn",
+        payload: { token: null },
+        res: {
+          obj_name: "settings",
+        },
+      },
+    ],
+    pushover_otp: [
+      {
+        //url: '/rpc/generate_otp_fn',
+        url: "/rpc/pushover_subscribe_link_fn",
+        //payload: { email: 'demo+kapla@openplotter.cloud' },
+        res: {
+          obj_name: "pushover_link",
+        },
+      },
+      {
+        url: "/rpc/pushover_fn",
+        payload: { token: null, pushover_user_key: "1234567890azerty!" },
+        res: {
+          obj_name: "settings",
+        },
+      },
+    ],
+    telegram_otp: [
+      {
+        url: "/rpc/update_user_preferences_fn",
+        payload: { key: "{email_notifications}", value: false },
+      },
+      {
+        url: "/rpc/update_user_preferences_fn",
+        payload: { key: "{phone_notifications}", value: false },
+      },
+      {
+        //url: '/rpc/generate_otp_fn',
+        url: "/rpc/telegram_otp_fn",
+        payload: { email: "demo+kapla@openplotter.cloud" },
+        res: {
+          otp: 0,
+        },
+      },
+      {
+        url: "/rpc/telegram_fn",
+        payload: {
+          token: null,
+          telegram_obj: {
+            chat: {
+              id: 1234567890,
+              type: "private",
+              title: null,
+              all_members_are_administrators: null,
+            },
+            date: "NOW",
+            from: {
+              id: 1234567890,
+              is_bot: false,
+              first_name: "Kapla",
+              language_code: "en",
+            },
+          },
+        },
+        res: {},
+      },
+    ],
+    telegram: { payload: { user_id: 1234567890 } },
+    telegram_fn: [{ url: "/rpc/vessel_fn" }, { url: "/monitoring_view" }],
+    badges: {
+      url: "/rpc/settings_fn",
+      payload: null,
+      res: {
+        obj_name: "settings",
+      },
+    },
+    monitoring: [
+      {
+        url: "/monitoring_view",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_view2",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_view3",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_voltage",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_temperatures",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_humidity",
+        payload: null,
+        res: {},
+      },
+    ],
+    eventlogs: {
+      url: "/eventlogs_view",
+      payload: null,
+      res: {},
+    },
+    public: [
+      {
+        url: "/rpc/update_user_preferences_fn",
+        payload: { key: "{public_logs}", value: true },
+      },
+      {
+        url: "/rpc/update_user_preferences_fn",
+        payload: { key: "{public_monitoring}", value: true },
+      },
+    ],
+  },
+  {
+    cname: process.env.PGSAIL_API_URI,
+    name: "PostgSail unit test, aava",
+    signin: {
+      email: "demo+aava@openplotter.cloud",
+      pass: "test",
+      firstname: "first_aava",
+      lastname: "last_aava",
+    },
+    login: { email: "demo+aava@openplotter.cloud", pass: "test" },
+    preferences: { key: "{email_valid}", value: false },
+    email_otp: [
+      {
+        url: "/rpc/generate_otp_fn",
+        payload: { email: "demo+aava@openplotter.cloud" },
+        res: {
+          otp: 0,
+        },
+      },
+      {
+        url: "/rpc/email_fn",
+        payload: { token: null },
+        res: {
+          obj_name: "settings",
+        },
+      },
+    ],
+    pushover_otp: [
+      {
+        //url: '/rpc/generate_otp_fn',
+        url: "/rpc/pushover_subscribe_link_fn",
+        //payload: { email: 'demo+aava@openplotter.cloud' },
+        res: {
+          obj_name: "pushover_link",
+        },
+      },
+      {
+        url: "/rpc/pushover_fn",
+        payload: { token: null, pushover_user_key: "0987654321qwerty!" },
+        res: {
+          obj_name: "settings",
+        },
+      },
+    ],
+    telegram_otp: [
+      {
+        url: "/rpc/update_user_preferences_fn",
+        payload: { key: "{email_notifications}", value: false },
+      },
+      {
+        url: "/rpc/update_user_preferences_fn",
+        payload: { key: "{phone_notifications}", value: false },
+      },
+      {
+        //url: '/rpc/generate_otp_fn',
+        url: "/rpc/telegram_otp_fn",
+        payload: { email: "demo+aava@openplotter.cloud" },
+        res: {
+          otp: 0,
+        },
+      },
+      {
+        url: "/rpc/telegram_fn",
+        payload: {
+          token: null,
+          telegram_obj: {
+            chat: {
+              id: 9876543210,
+              type: "private",
+              title: null,
+              all_members_are_administrators: null,
+            },
+            date: "NOW",
+            from: {
+              id: 9876543210,
+              is_bot: false,
+              first_name: "Aava",
+              language_code: "en",
+            },
+          },
+        },
+        res: {},
+      },
+    ],
+    telegram: { payload: { user_id: 9876543210 } },
+    telegram_fn: [{ url: "/rpc/vessel_fn" }, { url: "/monitoring_view" }],
+    badges: {
+      url: "/rpc/settings_fn",
+      payload: null,
+      res: {
+        obj_name: "settings",
+      },
+    },
+    monitoring: [
+      {
+        url: "/monitoring_view",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_view2",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_view3",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_voltage",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_temperatures",
+        payload: null,
+        res: {},
+      },
+      {
+        url: "/monitoring_humidity",
+        payload: null,
+        res: {},
+      },
+    ],
+    eventlogs: {
+      url: "/eventlogs_view",
+      payload: null,
+      res: {},
+    },
+    public: [
+      {
+        url: "/rpc/update_user_preferences_fn",
+        payload: { key: "{public_logs}", value: true },
+      },
+      {
+        url: "/rpc/update_user_preferences_fn",
+        payload: { key: "{public_monitoring}", value: true },
+      },
+    ],
+  },
+].forEach(function (test) {
+  //console.log(`${test.cname}`);
+  describe(`${test.name}`, function () {
+    request = supertest.agent(test.cname);
+    request.set("User-Agent", "PostgSail unit tests");
+
+    describe("Get JWT user_role", function () {
+      it("/rpc/signup return user_role jwt token", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .post("/rpc/signup")
+          .send(test.signin)
+          .set("Accept", "application/json")
+          .end(function (err, res) {
+            res.status.should.equal(200);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            should.exist(res.body.token);
+            user_jwt = res.body.token;
+            should.exist(user_jwt);
+            done(err);
+          });
+      });
+
+      it("/rpc/login return user_role jwt token", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .post("/rpc/login")
+          .send(test.login)
+          .set("Accept", "application/json")
+          .end(function (err, res) {
+            res.status.should.equal(200);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            should.exist(res.body.token);
+            //res.body.token.should.match(user_jwt);
+            console.log(user_jwt);
+            should.exist(user_jwt);
+            done(err);
+          });
+      });
+    }); // JWT user_role
+
+    describe("Set preferences email_notifications, JWT user_role", function () {
+      it("/rpc/update_user_preferences_fn return true", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .post("/rpc/update_user_preferences_fn")
+          .send(test.preferences)
+          .set("Authorization", `Bearer ${user_jwt}`)
+          .set("Accept", "application/json")
+          .set("Content-Type", "application/json")
+          .end(function (err, res) {
+            res.status.should.equal(200);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            //console.log(res.text);
+            should.exist(res.text);
+            res.text.should.match("true");
+            done(err);
+          });
+      });
+    }); // JWT user_role
+
+    describe("Function email OTP endpoint, JWT user_role", function () {
+      let otp = null;
+      test.email_otp.forEach(function (subtest) {
+        it(`${subtest.url}`, function (done) {
+          try {
+            //console.log(`${subtest.url} ${subtest.payload}`);
+            if (otp) {
+              subtest.payload.token = otp;
+            }
+            // Reset agent so we do not save cookies
+            request = supertest.agent(test.cname);
+            request
+              .post(subtest.url)
+              .send(subtest.payload)
+              .set("Authorization", `Bearer ${user_jwt}`)
+              .set("Accept", "application/json")
+              .end(function (err, res) {
+                res.status.should.equal(200);
+                should.exist(res.header["content-type"]);
+                should.exist(res.header["server"]);
+                res.header["content-type"].should.match(
+                  new RegExp("json", "g")
+                );
+                res.header["server"].should.match(new RegExp("postgrest", "g"));
+                console.log(res.body);
+                should.exist(res.body);
+                if (subtest.url == "/rpc/generate_otp_fn") {
+                  otp = res.body;
+                } else {
+                  res.text.should.match("true");
+                }
+                done(err);
+              });
+          } catch (error) {
+            done();
+          }
+        });
+      });
+    }); // email OTP endpoint
+
+    describe("Function Pushover OTP endpoint, JWT user_role", function () {
+      let otp = null;
+      test.pushover_otp.forEach(function (subtest) {
+        it(`${subtest.url}`, function (done) {
+          try {
+            //console.log(`${subtest.url} ${subtest.payload}`);
+            if (otp) {
+              subtest.payload.token = otp;
+            }
+            // Reset agent so we do not save cookies
+            request = supertest.agent(test.cname);
+            request
+              .post(subtest.url)
+              .send(subtest.payload)
+              .set("Authorization", `Bearer ${user_jwt}`)
+              .set("Accept", "application/json")
+              .end(function (err, res) {
+                res.status.should.equal(200);
+                should.exist(res.header["content-type"]);
+                should.exist(res.header["server"]);
+                res.header["content-type"].should.match(
+                  new RegExp("json", "g")
+                );
+                res.header["server"].should.match(new RegExp("postgrest", "g"));
+                //console.log(res.body);
+                should.exist(res.body);
+                if (subtest.url == "/rpc/pushover_subscribe_link_fn") {
+                  should.exist(res.body.pushover_link.link);
+                  let rx = /3D(\d+)\&/g;
+                  //console.log(rx.exec(res.body.pushover_link.link)[1]);
+                  let arr = rx.exec(res.body.pushover_link.link);
+                  //console.log(arr);
+                  console.log(arr[1]);
+                  otp = arr[1];
+                } else {
+                  res.text.should.match("true");
+                }
+                done(err);
+              });
+          } catch (error) {
+            done();
+          }
+        });
+      });
+    }); // pushover OTP endpoint
+
+    describe("Function Telegram OTP endpoint, JWT user_role", function () {
+      let otp = null;
+      test.telegram_otp.forEach(function (subtest) {
+        it(`${subtest.url}`, function (done) {
+          try {
+            console.log(`${subtest.url} ${subtest.payload.email} ${otp}`);
+            if (otp) {
+              subtest.payload.token = otp;
+              console.log(subtest.payload.telegram_obj.date);
+              subtest.payload.telegram_obj.date = moment.utc().format();
+            }
+            // Reset agent so we do not save cookies
+            request = supertest.agent(test.cname);
+            request
+              .post(subtest.url)
+              .send(subtest.payload)
+              .set("Authorization", `Bearer ${user_jwt}`)
+              .set("Accept", "application/json")
+              .end(function (err, res) {
+                res.status.should.equal(200);
+                should.exist(res.header["content-type"]);
+                should.exist(res.header["server"]);
+                res.header["content-type"].should.match(
+                  new RegExp("json", "g")
+                );
+                res.header["server"].should.match(new RegExp("postgrest", "g"));
+                console.log(res.body);
+                should.exist(res.body);
+                if (subtest.url == "/rpc/telegram_otp_fn") {
+                  console.log(res.body.otp_code);
+                  otp = res.body.otp_code;
+                } else {
+                  console.log(res.text);
+                  res.text.should.match("true");
+                  otp = null;
+                }
+                done(err);
+              });
+          } catch (error) {
+            done();
+          }
+        });
+      });
+    }); // telegram OTP endpoint
+
+    describe("telegram session, anonymous", function () {
+      it("/rpc/telegram return jwt token", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .post("/rpc/telegram")
+          .send(test.telegram.payload)
+          .set("Accept", "application/json")
+          .set("Content-Type", "application/json")
+          .end(function (err, res) {
+            res.status.should.equal(200);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            should.exist(res.body.token);
+            user_jwt = res.body.token;
+            console.log(res.body.token);
+            done(err);
+          });
+      });
+    }); // anonymous JWT
+
+    describe("Telegram endpoint, JWT user_role", function () {
+      let otp = null;
+      test.telegram_fn.forEach(function (subtest) {
+        it(`${subtest.url}`, function (done) {
+          try {
+            //console.log(`${subtest.url} ${subtest.res_body_length}`);
+            // Reset agent so we do not save cookies
+            request = supertest.agent(test.cname);
+            request
+              .get(subtest.url)
+              .set("Authorization", `Bearer ${user_jwt}`)
+              .set("Accept", "application/json")
+              .end(function (err, res) {
+                res.status.should.equal(200);
+                should.exist(res.header["content-type"]);
+                should.exist(res.header["server"]);
+                res.header["content-type"].should.match(
+                  new RegExp("json", "g")
+                );
+                res.header["server"].should.match(new RegExp("postgrest", "g"));
+                console.log(res.body);
+                should.exist(res.body);
+                done(err);
+              });
+          } catch (error) {
+            done();
+          }
+        });
+      });
+    }); // Function endpoint
+
+    /*
+  describe("Function others endpoint, JWT user_role", function(){
+
+    let otp = null;
+    test.others_fn.forEach(function (subtest) {
+      it(`${subtest.url}`, function(done) {
+        try {
+          //console.log(`${subtest.url} ${subtest.res_body_length}`);
+          // Reset agent so we do not save cookies
+          request = supertest.agent(test.cname);
+          request
+            .post(subtest.url)
+            .send(subtest.payload)
+            .set('Authorization', `Bearer ${user_jwt}`)
+            .set('Accept', 'application/json')
+            .end(function(err,res){
+              res.status.should.equal(200);
+              should.exist(res.header['content-type']);
+              should.exist(res.header['server']);
+              res.header['content-type'].should.match(new RegExp('json','g'));
+              res.header['server'].should.match(new RegExp('postgrest','g'));
+              //console.log(res.body);
+              should.exist(res.body);
+              if (subtest.url == '/rpc/generate_otp_fn') {
+                otp = res.body.text();
+              }
+              done(err);
+            });
+        }
+        catch (error) {
+          done();
+        }
+      });
+    });
+  }); // Function endpoint
+*/
+
+    describe("Badges, user jwt", function () {
+      it("/rpc/settings_fn return user settings", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .post("/rpc/settings_fn")
+          .set("Authorization", `Bearer ${user_jwt}`)
+          .set("Accept", "application/json")
+          .end(function (err, res) {
+            res.status.should.equal(200);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            console.log(res.body);
+            should.exist(res.body.settings);
+            should.exist(res.body.settings.preferences.badges);
+            let badges = res.body.settings.preferences.badges;
+            //console.log(Object.keys(badges));
+            Object.keys(badges).length.should.be.aboveOrEqual(3);
+            badges.should.have.properties(
+              "Helmsman",
+              "Wake Maker",
+              "Stormtrooper"
+            );
+            done(err);
+          });
+      });
+    }); // user JWT
+
+    describe("Function monitoring endpoint, JWT user_role", function () {
+      let otp = null;
+      test.monitoring.forEach(function (subtest) {
+        it(`${subtest.url}`, function (done) {
+          try {
+            // Reset agent so we do not save cookies
+            request = supertest.agent(test.cname);
+            request
+              .get(subtest.url)
+              .set("Authorization", `Bearer ${user_jwt}`)
+              .set("Accept", "application/json")
+              .end(function (err, res) {
+                res.status.should.equal(200);
+                should.exist(res.header["content-type"]);
+                should.exist(res.header["server"]);
+                res.header["content-type"].should.match(
+                  new RegExp("json", "g")
+                );
+                res.header["server"].should.match(new RegExp("postgrest", "g"));
+                //console.log(res.body);
+                should.exist(res.body);
+                //let monitoring = res.body;
+                //console.log(monitoring);
+                // minimum set for static monitoring page
+                // no value for humidity monitoring
+                //monitoring.length.should.be.aboveOrEqual(21);
+                done(err);
+              });
+          } catch (error) {
+            done();
+          }
+        });
+      });
+    }); // Monitoring endpoint
+
+    describe("Event Logs, user jwt", function () {
+      it("/eventlogs_view endpoint, list process_queue, JWT user_role", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .get("/eventlogs_view")
+          .set("Authorization", `Bearer ${user_jwt}`)
+          .set("Accept", "application/json")
+          .end(function (err, res) {
+            res.status.should.equal(200);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            //console.log(res.body);
+            should.exist(res.body);
+            let event = res.body;
+            //console.log(event);
+            // minimum events log for kapla & aava 13 + 4 email_otp = 17
+            event.length.should.be.aboveOrEqual(13);
+            done(err);
+          });
+      });
+    }); // user JWT
+
+    describe("Function update preference for public access endpoint, JWT user_role", function () {
+      test.public.forEach(function (subtest) {
+        it(`${subtest.url}`, function (done) {
+          try {
+            // Reset agent so we do not save cookies
+            request = supertest.agent(test.cname);
+            request
+              .post(subtest.url)
+              .send(subtest.payload)
+              .set("Authorization", `Bearer ${user_jwt}`)
+              .set("Accept", "application/json")
+              .end(function (err, res) {
+                res.status.should.equal(200);
+                should.exist(res.header["content-type"]);
+                should.exist(res.header["server"]);
+                res.header["server"].should.match(new RegExp("postgrest", "g"));
+                //console.log(res.body);
+                should.exist(res.body);
+                //let monitoring = res.body;
+                //console.log(monitoring);
+                // minimum set for static monitoring page
+                // no value for humidity monitoring
+                //monitoring.length.should.be.aboveOrEqual(21);
+                done(err);
+              });
+          } catch (error) {
+            done();
+          }
+        });
+      });
+    }); // Monitoring endpoint
+
+  }); // OpenAPI description
+}); // Users Array

tests/index5.js

@@ -0,0 +1,223 @@
+"use strict";
+/*
+ * Unit test #5
+ * Public/Anonymous access
+ *
+ * process.env.PGSAIL_API_URI = from inside the docker
+ *
+ * npm install supertest should mocha mochawesome moment
+ * alias mocha="./node_modules/mocha/bin/_mocha"
+ * mocha index5.js --reporter mochawesome --reporter-options reportDir=/mnt/postgsail/,reportFilename=report_api.html
+ *
+ */
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+const supertest = require("supertest");
+// Deprecated
+const should = require("should");
+//const chai = require("chai");
+//const should = chai.should();
+let request = null;
+var moment = require("moment");
+
+// Users Array
+[
+  {
+    cname: process.env.PGSAIL_API_URI,
+    name: "PostgSail unit test kapla",
+    logs: {
+      url: "/logs_view",
+      header: { name: "x-is-public", value: btoa("kapla,public_logs_list,0") },
+      payload: null,
+      res: {},
+    },
+    log: {
+      url: "/log_view?id=eq.1",
+      header: { name: "x-is-public", value: btoa("kapla,public_logs,1") },
+      payload: null,
+      res: {},
+    },
+    monitoring: {
+      url: "/monitoring_view",
+      header: { name: "x-is-public", value: btoa("kapla,public_monitoring,0") },
+      payload: null,
+      res: {},
+    },
+    timelapse: {
+      url: "/rpc/timelapse_fn",
+      header: { name: "x-is-public", value: btoa("kapla,public_timelapse,1") },
+      payload: null,
+      res: {},
+    },
+    timelapse_full: {
+      url: "/rpc/timelapse_fn",
+      header: { name: "x-is-public", value: btoa("kapla,public_timelapse,0") },
+      payload: null,
+      res: {},
+    },
+    stats_logs: {
+      url: "/rpc/stats_logs_fn",
+      header: { name: "x-is-public", value: btoa("kapla,public_stats,0") },
+      payload: null,
+      res: {},
+    },
+    stats_stays: {
+      url: "/rpc/stats_stay_fn",
+      header: { name: "x-is-public", value: btoa("kapla,public_stats,0") },
+      payload: null,
+      res: {},
+    },
+    export_gpx: {
+      url: "/rpc/export_logbook_gpx_fn",
+      header: { name: "x-is-public", value: btoa("kapla,public_logs,0") },
+      payload: null,
+      res: {},
+    },
+  },
+  {
+    cname: process.env.PGSAIL_API_URI,
+    name: "PostgSail unit test, aava",
+    logs: {
+      url: "/logs_view",
+      header: { name: "x-is-public", value: btoa("aava,public_logs_list,0") },
+      payload: null,
+      res: {},
+    },
+    log: {
+      url: "/log_view?id=eq.3",
+      header: { name: "x-is-public", value: btoa("aava,public_logs,3") },
+      payload: null,
+      res: {},
+    },
+    monitoring: {
+      url: "/monitoring_view",
+      header: { name: "x-is-public", value: btoa("aava,public_monitoring,0") },
+      payload: null,
+      res: {},
+    },
+    timelapse: {
+      url: "/rpc/timelapse_fn",
+      header: { name: "x-is-public", value: btoa("aava,public_timelapse,3") },
+      payload: null,
+      res: {},
+    },
+    timelapse_full: {
+      url: "/rpc/timelapse_fn",
+      header: { name: "x-is-public", value: btoa("aava,public_timelapse,0") },
+      payload: null,
+      res: {},
+    },
+    stats_logs: {
+      url: "/rpc/stats_logs_fn",
+      header: { name: "x-is-public", value: btoa("aava,public_stats,0") },
+      payload: null,
+      res: {},
+    },
+    stats_stays: {
+      url: "/rpc/stats_stay_fn",
+      header: { name: "x-is-public", value: btoa("kapla,public_stats,0") },
+      payload: null,
+      res: {},
+    },
+    export_gpx: {
+      url: "/rpc/export_logbook_gpx_fn",
+      header: { name: "x-is-public", value: btoa("aava,public_logs,0") },
+      payload: null,
+      res: {},
+    },
+  },
+].forEach(function (test) {
+  //console.log(`${test.cname}`);
+  describe(`${test.name}`, function () {
+    request = supertest.agent(test.cname);
+    request.set("User-Agent", "PostgSail unit tests");
+
+    describe("With no JWT as api_anonymous", function () {
+      it("/logs_view, api_anonymous no jwt token", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .get(test.logs.url)
+          .set(test.logs.header.name, test.logs.header.value)
+          .set("Accept", "application/json")
+          .end(function (err, res) {
+            res.status.should.equal(404);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            done(err);
+          });
+      });
+      it("/log_view, api_anonymous no jwt token", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .get(test.log.url)
+          .set(test.log.header.name, test.log.header.value)
+          .set("Accept", "application/json")
+          .end(function (err, res) {
+            res.status.should.equal(200);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            done(err);
+          });
+      });
+      it("/monitoring_view, api_anonymous no jwt token", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .get(test.monitoring.url)
+          .set(test.monitoring.header.name, test.monitoring.header.value)
+          .set("Accept", "application/json")
+          .end(function (err, res) {
+            console.log(res.text);
+            res.status.should.equal(200);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            done(err);
+          });
+      });
+      it("/rpc/timelapse_fn, api_anonymous no jwt token", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .post(test.timelapse.url)
+          .set(test.timelapse.header.name, test.timelapse.header.value)
+          .set("Accept", "application/json")
+          .end(function (err, res) {
+            console.log(res.text);
+            res.status.should.equal(404); // return 404 as it is not enable in user settings.
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            done(err);
+          });
+      });
+      it("/rpc/export_logbook_gpx_fn, api_anonymous no jwt token", function (done) {
+        // Reset agent so we do not save cookies
+        request = supertest.agent(test.cname);
+        request
+          .post(test.export_gpx.url)
+          .send({_id: 1})
+          .set(test.export_gpx.header.name, test.export_gpx.header.value)
+          .set("Accept", "application/json")
+          .end(function (err, res) {
+            console.log(res.text)
+            res.status.should.equal(401);
+            should.exist(res.header["content-type"]);
+            should.exist(res.header["server"]);
+            res.header["content-type"].should.match(new RegExp("json", "g"));
+            res.header["server"].should.match(new RegExp("postgrest", "g"));
+            done(err);
+          });
+      });
+    }); // user JWT
+  }); // OpenAPI description
+}); // Users Array

tests/metrics_sample_aava.json

@@ -0,0 +1,603 @@
+{
+"metrics": [
+	{
+		"time" : "2022-07-31T11:28:13.331Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7231605,
+		"longitude" : 24.7358807,
+		"speedoverground" : 7.1,
+		"courseovergroundtrue" : 188.9,
+		"windspeedapparent" : 13.9,
+		"anglespeedapparent" : 56.0,
+		"status" : "moored",
+		"metrics" : {"navigation.log": 17441210, "navigation.trip.log": 80099, "navigation.headingTrue": 3.3179, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 36.219, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.48, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 19.6, "electrical.batteries.1.voltage": 13.38, "navigation.gnss.antennaAltitude": 2.21, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 36.22, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 89, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 9, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:29:13.340Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7213961,
+		"longitude" : 24.7349507,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 197.4,
+		"windspeedapparent" : 15.4,
+		"anglespeedapparent" : 43.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441395, "navigation.trip.log": 80284, "navigation.headingTrue": 3.4924, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 32.289, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 231, "electrical.batteries.1.voltage": 14.45, "navigation.gnss.antennaAltitude": -0.04, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 32.29, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 57, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 4, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 11, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:29:13.340Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7213961,
+		"longitude" : 24.7349507,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 197.4,
+		"windspeedapparent" : 15.4,
+		"anglespeedapparent" : 43.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441395, "navigation.trip.log": 80284, "navigation.headingTrue": 3.4924, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 32.289, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 231, "electrical.batteries.1.voltage": 14.45, "navigation.gnss.antennaAltitude": -0.04, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 32.29, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 57, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 4, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 11, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:30:28.338Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7190763,
+		"longitude" : 24.733775,
+		"speedoverground" : 7.1,
+		"courseovergroundtrue" : 194.4,
+		"windspeedapparent" : 16.3,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441580, "navigation.trip.log": 80544, "navigation.headingTrue": 3.4226, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 23.808999999999997, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.61, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 231.5, "electrical.batteries.1.voltage": 13.02, "navigation.gnss.antennaAltitude": 2.06, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 23.81, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 73, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 1, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 1, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:31:28.348Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7173052,
+		"longitude" : 24.7325741,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 198.8,
+		"windspeedapparent" : 15.8,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441766, "navigation.trip.log": 80747, "navigation.headingTrue": 3.5972, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 20.948999999999998, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.47, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 192.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 0.21, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 20.95, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 64, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:32:28.364Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7156422,
+		"longitude" : 24.731211599999998,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 203.3,
+		"windspeedapparent" : 13.7,
+		"anglespeedapparent" : 58.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442136, "navigation.trip.log": 80951, "navigation.headingTrue": 3.5361, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 17.529, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 2.93, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 105.2, "electrical.batteries.1.voltage": 14.55, "navigation.gnss.antennaAltitude": 2.49, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 17.53, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 43, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 4, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 11, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:33:28.377Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7139966,
+		"longitude" : 24.7299656,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 200.4,
+		"windspeedapparent" : 15.6,
+		"anglespeedapparent" : 44.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442321, "navigation.trip.log": 81136, "navigation.headingTrue": 3.571, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 13.999, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 70.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 2.69, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 34, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:34:28.396Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7124464,
+		"longitude" : 24.728924,
+		"speedoverground" : 5.8,
+		"courseovergroundtrue" : 197.8,
+		"windspeedapparent" : 12.2,
+		"anglespeedapparent" : 31.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442506, "navigation.trip.log": 81321, "navigation.headingTrue": 3.5535, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 13.999, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.07, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 43.9, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 2.11, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 66, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:35:28.413Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7106379,
+		"longitude" : 24.728088,
+		"speedoverground" : 6.7,
+		"courseovergroundtrue" : 187.8,
+		"windspeedapparent" : 13.7,
+		"anglespeedapparent" : 42.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442692, "navigation.trip.log": 81507, "navigation.headingTrue": 3.4313, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 14.029, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 36.1, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 2.78, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14.03, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 69, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:36:28.424Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7087125,
+		"longitude" : 24.7276837,
+		"speedoverground" : 7.1,
+		"courseovergroundtrue" : 185.4,
+		"windspeedapparent" : 13.5,
+		"anglespeedapparent" : 51.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442877, "navigation.trip.log": 81692, "navigation.headingTrue": 3.3004, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 22.689, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 25.2, "electrical.batteries.1.voltage": 14.55, "navigation.gnss.antennaAltitude": 3.24, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 22.69, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 45, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:37:28.444Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7245499,
+		"longitude" : 24.736394999999998,
+		"speedoverground" : 6.7,
+		"courseovergroundtrue" : 196.5,
+		"windspeedapparent" : 14.1,
+		"anglespeedapparent" : 42.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441025, "navigation.trip.log": 79951, "navigation.headingTrue": 3.475, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 71.039, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 16.4, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 2.32, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 71.04, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 64, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:38:28.483Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7227198,
+		"longitude" : 24.735699,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 186.4,
+		"windspeedapparent" : 13.9,
+		"anglespeedapparent" : 44.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441210, "navigation.trip.log": 80136, "navigation.headingTrue": 3.4401, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 33.169000000000004, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 172, "electrical.batteries.1.voltage": 13.35, "navigation.gnss.antennaAltitude": 2.11, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 33.17, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 32, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 5, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 6, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 13, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 1, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 1, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:39:28.509Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7209298,
+		"longitude" : 24.73472,
+		"speedoverground" : 6.8,
+		"courseovergroundtrue" : 190.7,
+		"windspeedapparent" : 15.4,
+		"anglespeedapparent" : 38.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441395, "navigation.trip.log": 80340, "navigation.headingTrue": 3.4663, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 30.738999999999997, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.47, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 211.6, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 0.76, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 30.74, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 52, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 9, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:40:28.539Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7190763,
+		"longitude" : 24.733774999999998,
+		"speedoverground" : 7.1,
+		"courseovergroundtrue" : 194.4,
+		"windspeedapparent" : 16.3,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441580, "navigation.trip.log": 80544, "navigation.headingTrue": 3.4226, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 23.808999999999997, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.61, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 231.5, "electrical.batteries.1.voltage": 13.02, "navigation.gnss.antennaAltitude": 2.06, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 23.81, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 73, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 1, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 1, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:41:28.561Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7173052,
+		"longitude" : 24.7325741,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 198.8,
+		"windspeedapparent" : 15.8,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441766, "navigation.trip.log": 80747, "navigation.headingTrue": 3.5972, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 20.948999999999998, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.47, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 192.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 0.39, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 20.95, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 64, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:42:28.569Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7156422,
+		"longitude" : 24.7312116,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 203.3,
+		"windspeedapparent" : 13.7,
+		"anglespeedapparent" : 58.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442136, "navigation.trip.log": 80951, "navigation.headingTrue": 3.5361, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 17.529, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 2.93, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 107.6, "electrical.batteries.1.voltage": 14.55, "navigation.gnss.antennaAltitude": 2.49, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 17.53, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 43, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 4, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 11, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:43:28.603Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7139966,
+		"longitude" : 24.7299656,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 200.4,
+		"windspeedapparent" : 15.6,
+		"anglespeedapparent" : 44.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442321, "navigation.trip.log": 81136, "navigation.headingTrue": 3.571, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 13.999, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 70.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 2.69, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 34, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:44:28.629Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7124464,
+		"longitude" : 24.728924,
+		"speedoverground" : 5.7,
+		"courseovergroundtrue" : 197.6,
+		"windspeedapparent" : 12.2,
+		"anglespeedapparent" : 31.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442506, "navigation.trip.log": 81321, "navigation.headingTrue": 3.571, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 13.999, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.07, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 43.9, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 2.05, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 66, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:45:28.645Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7106379,
+		"longitude" : 24.728088,
+		"speedoverground" : 6.7,
+		"courseovergroundtrue" : 187.8,
+		"windspeedapparent" : 13.7,
+		"anglespeedapparent" : 42.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442692, "navigation.trip.log": 81507, "navigation.headingTrue": 3.4313, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 14.029, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 36.1, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 2.78, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14.03, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 69, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:46:28.664Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7087125,
+		"longitude" : 24.7276837,
+		"speedoverground" : 7.0,
+		"courseovergroundtrue" : 185.4,
+		"windspeedapparent" : 13.5,
+		"anglespeedapparent" : 51.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442877, "navigation.trip.log": 81692, "navigation.headingTrue": 3.3004, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 22.689, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 25.2, "electrical.batteries.1.voltage": 14.55, "navigation.gnss.antennaAltitude": 3.24, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 22.69, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 45, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:47:28.696Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7245499,
+		"longitude" : 24.736394999999998,
+		"speedoverground" : 6.7,
+		"courseovergroundtrue" : 196.5,
+		"windspeedapparent" : 14.1,
+		"anglespeedapparent" : 42.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441025, "navigation.trip.log": 79951, "navigation.headingTrue": 3.475, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 71.039, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 16.4, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 2.32, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 71.04, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 64, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:48:28.712Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7226901,
+		"longitude" : 24.735683899999998,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 187.7,
+		"windspeedapparent" : 14.9,
+		"anglespeedapparent" : 44.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441210, "navigation.trip.log": 80136, "navigation.headingTrue": 3.4313, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 33.169000000000004, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 172, "electrical.batteries.1.voltage": 13.35, "navigation.gnss.antennaAltitude": 2.13, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 33.17, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 32, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 5, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 6, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 13, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 1, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 1, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:49:28.726Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7209298,
+		"longitude" : 24.73472,
+		"speedoverground" : 6.8,
+		"courseovergroundtrue" : 190.7,
+		"windspeedapparent" : 15.4,
+		"anglespeedapparent" : 38.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441395, "navigation.trip.log": 80340, "navigation.headingTrue": 3.4663, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 30.738999999999997, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.47, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 211.6, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 0.76, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 30.74, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 52, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 9, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:50:28.743Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7190454,
+		"longitude" : 24.7337548,
+		"speedoverground" : 7.0,
+		"courseovergroundtrue" : 194.4,
+		"windspeedapparent" : 16.3,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441580, "navigation.trip.log": 80544, "navigation.headingTrue": 3.4226, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 23.808999999999997, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.61, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 231.5, "electrical.batteries.1.voltage": 13.02, "navigation.gnss.antennaAltitude": 2.06, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 23.81, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 73, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 1, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 1, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:51:28.762Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7172775,
+		"longitude" : 24.7325491,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 198.3,
+		"windspeedapparent" : 13.9,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441766, "navigation.trip.log": 80747, "navigation.headingTrue": 3.5797, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 20.948999999999998, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.47, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 192.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 0.39, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 20.95, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 64, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:52:28.783Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7156422,
+		"longitude" : 24.7312116,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 203.3,
+		"windspeedapparent" : 15.6,
+		"anglespeedapparent" : 58.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442136, "navigation.trip.log": 80951, "navigation.headingTrue": 3.5361, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 17.529, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 2.93, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 107.6, "electrical.batteries.1.voltage": 14.55, "navigation.gnss.antennaAltitude": 2.49, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 17.53, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 43, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 4, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 11, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:53:28.800Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7139716,
+		"longitude" : 24.7299463,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 200.4,
+		"windspeedapparent" : 14.1,
+		"anglespeedapparent" : 44.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442321, "navigation.trip.log": 81136, "navigation.headingTrue": 3.571, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 13.999, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 70.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 2.69, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 34, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:54:28.819Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7124464,
+		"longitude" : 24.728924,
+		"speedoverground" : 5.7,
+		"courseovergroundtrue" : 197.6,
+		"windspeedapparent" : 15.9,
+		"anglespeedapparent" : 31.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442506, "navigation.trip.log": 81321, "navigation.headingTrue": 3.571, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 13.999, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.07, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 43.9, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 2.05, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 66, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:55:28.837Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7106379,
+		"longitude" : 24.728088,
+		"speedoverground" : 6.7,
+		"courseovergroundtrue" : 187.8,
+		"windspeedapparent" : 16.9,
+		"anglespeedapparent" : 42.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442692, "navigation.trip.log": 81507, "navigation.headingTrue": 3.4313, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 14.029, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 36.1, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 2.74, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14.03, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 69, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:56:28.855Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7086808,
+		"longitude" : 24.7276789,
+		"speedoverground" : 7.0,
+		"courseovergroundtrue" : 185.4,
+		"windspeedapparent" : 13.5,
+		"anglespeedapparent" : 51.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442877, "navigation.trip.log": 81692, "navigation.headingTrue": 3.3004, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 22.689, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 25.2, "electrical.batteries.1.voltage": 14.55, "navigation.gnss.antennaAltitude": 3.24, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 22.69, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 45, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:57:28.876Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7245198,
+		"longitude" : 24.7363702,
+		"speedoverground" : 6.7,
+		"courseovergroundtrue" : 196.5,
+		"windspeedapparent" : 14.1,
+		"anglespeedapparent" : 42.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441025, "navigation.trip.log": 79951, "navigation.headingTrue": 3.475, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 71.039, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 16.4, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 2.32, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 71.04, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 64, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:58:28.899Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7226901,
+		"longitude" : 24.735683899999998,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 187.7,
+		"windspeedapparent" : 14.9,
+		"anglespeedapparent" : 44.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441210, "navigation.trip.log": 80136, "navigation.headingTrue": 3.4313, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 33.169000000000004, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 172, "electrical.batteries.1.voltage": 13.35, "navigation.gnss.antennaAltitude": 2.13, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 33.17, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 32, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 5, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 6, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 13, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 1, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 1, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T11:59:28.928Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7208986,
+		"longitude" : 24.734705599999998,
+		"speedoverground" : 6.8,
+		"courseovergroundtrue" : 190.7,
+		"windspeedapparent" : 15.4,
+		"anglespeedapparent" : 38.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441395, "navigation.trip.log": 80358, "navigation.headingTrue": 3.5099, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 30.738999999999997, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.47, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 211.6, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 0.78, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 30.74, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 52, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 9, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:00:28.941Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7190454,
+		"longitude" : 24.7337548,
+		"speedoverground" : 7.0,
+		"courseovergroundtrue" : 194.4,
+		"windspeedapparent" : 17.0,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441580, "navigation.trip.log": 80544, "navigation.headingTrue": 3.4226, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 23.808999999999997, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.61, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 231.5, "electrical.batteries.1.voltage": 13.02, "navigation.gnss.antennaAltitude": 2.06, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 23.81, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 73, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 1, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 1, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:01:28.966Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7172775,
+		"longitude" : 24.7325491,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 198.3,
+		"windspeedapparent" : 15.1,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441766, "navigation.trip.log": 80747, "navigation.headingTrue": 3.5797, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 20.948999999999998, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.47, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 192.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 0.39, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 20.95, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 64, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:02:28.982Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7156162,
+		"longitude" : 24.731190599999998,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 203.1,
+		"windspeedapparent" : 15.6,
+		"anglespeedapparent" : 58.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442136, "navigation.trip.log": 80951, "navigation.headingTrue": 3.5273, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 17.529, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 2.93, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 107.6, "electrical.batteries.1.voltage": 14.55, "navigation.gnss.antennaAltitude": 2.6, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 17.53, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 43, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 4, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 11, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:03:28.988Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7139716,
+		"longitude" : 24.7299463,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 200.4,
+		"windspeedapparent" : 14.1,
+		"anglespeedapparent" : 44.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442321, "navigation.trip.log": 81136, "navigation.headingTrue": 3.571, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 13.999, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.07, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 70.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 2.69, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 34, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:04:29.008Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7124174,
+		"longitude" : 24.7289112,
+		"speedoverground" : 5.7,
+		"courseovergroundtrue" : 197.6,
+		"windspeedapparent" : 15.9,
+		"anglespeedapparent" : 31.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442506, "navigation.trip.log": 81321, "navigation.headingTrue": 3.571, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 13.749, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.07, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 43.9, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 2.05, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 13.75, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 66, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:05:29.025Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7106066,
+		"longitude" : 24.7280837,
+		"speedoverground" : 6.7,
+		"courseovergroundtrue" : 191.2,
+		"windspeedapparent" : 16.9,
+		"anglespeedapparent" : 42.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442692, "navigation.trip.log": 81507, "navigation.headingTrue": 3.4313, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 13.539, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 36.1, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 2.74, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 13.54, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 69, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:06:29.043Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7086808,
+		"longitude" : 24.7276789,
+		"speedoverground" : 7.0,
+		"courseovergroundtrue" : 185.4,
+		"windspeedapparent" : 14.4,
+		"anglespeedapparent" : 51.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442877, "navigation.trip.log": 81710, "navigation.headingTrue": 3.3004, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 22.689, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 25.2, "electrical.batteries.1.voltage": 14.55, "navigation.gnss.antennaAltitude": 3.24, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 22.69, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 45, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:07:29.071Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7245198,
+		"longitude" : 24.7363702,
+		"speedoverground" : 6.7,
+		"courseovergroundtrue" : 196.5,
+		"windspeedapparent" : 14.1,
+		"anglespeedapparent" : 42.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441025, "navigation.trip.log": 79951, "navigation.headingTrue": 3.475, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 71.039, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.19, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 16.4, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 2.51, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 71.04, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 64, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:08:29.081Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7226901,
+		"longitude" : 24.7356839,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 187.7,
+		"windspeedapparent" : 14.9,
+		"anglespeedapparent" : 44.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441210, "navigation.trip.log": 80155, "navigation.headingTrue": 3.4313, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 33.719, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.09, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 172, "electrical.batteries.1.voltage": 13.35, "navigation.gnss.antennaAltitude": 2.13, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 33.72, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 72, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 6, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 13, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 1, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 1, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:09:29.094Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7208986,
+		"longitude" : 24.734705599999998,
+		"speedoverground" : 6.8,
+		"courseovergroundtrue" : 191.3,
+		"windspeedapparent" : 15.4,
+		"anglespeedapparent" : 38.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441395, "navigation.trip.log": 80358, "navigation.headingTrue": 3.5099, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 31.529, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.47, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 211.6, "electrical.batteries.1.voltage": 14.54, "navigation.gnss.antennaAltitude": 0.78, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 31.53, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 49, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 9, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:10:29.108Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7190454,
+		"longitude" : 24.7337548,
+		"speedoverground" : 7.0,
+		"courseovergroundtrue" : 194.4,
+		"windspeedapparent" : 17.0,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441580, "navigation.trip.log": 80544, "navigation.headingTrue": 3.4226, "navigation.gnss.satellites": 11, "environment.depth.belowKeel": 25.398999999999997, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.47, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 231.5, "electrical.batteries.1.voltage": 13.02, "navigation.gnss.antennaAltitude": 1.8, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 25.4, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 57, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 1, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 1, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:11:29.120Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7172775,
+		"longitude" : 24.7325491,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 198.3,
+		"windspeedapparent" : 15.1,
+		"anglespeedapparent" : 41.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17441766, "navigation.trip.log": 80747, "navigation.headingTrue": 3.5797, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 20.948999999999998, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.34, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 192.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 0.39, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 20.95, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 81, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 4, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:12:29.137Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7156162,
+		"longitude" : 24.731190599999998,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 203.1,
+		"windspeedapparent" : 15.6,
+		"anglespeedapparent" : 58.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.log": 17442136, "navigation.trip.log": 80951, "navigation.headingTrue": 3.5273, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 17.529, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.21, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 107.6, "electrical.batteries.1.voltage": 14.55, "navigation.gnss.antennaAltitude": 2.6, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 17.53, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 2, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 55, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 3, "network.n2k.ngt-1.130356.ch1.bandwidth": 2, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 5, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 11, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:13:29.150Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7139716,
+		"longitude" : 24.729946299999998,
+		"speedoverground" : 6.4,
+		"courseovergroundtrue" : 200.7,
+		"windspeedapparent" : 14.1,
+		"anglespeedapparent" : 44.0,
+		"status" : "anchored",
+		"metrics" : {"navigation.log": 17442321, "navigation.trip.log": 81136, "navigation.headingTrue": 3.571, "navigation.gnss.satellites": 10, "environment.depth.belowKeel": 14.209000000000001, "navigation.magneticVariation": 0.1414, "navigation.speedThroughWater": 3.07, "environment.water.temperature": 313.15, "electrical.batteries.1.current": 70.4, "electrical.batteries.1.voltage": 14.56, "navigation.gnss.antennaAltitude": 2.38, "network.n2k.ngt-1.130356.errorID": 0, "network.n2k.ngt-1.130356.modelID": 14, "environment.depth.belowTransducer": 14.21, "electrical.batteries.1.temperature": 299.82, "environment.depth.transducerToKeel": -0.001, "navigation.gnss.horizontalDilution": 0.8, "network.n2k.ngt-1.130356.ch1.rxLoad": 4, "network.n2k.ngt-1.130356.ch1.txLoad": 0, "network.n2k.ngt-1.130356.ch2.rxLoad": 0, "network.n2k.ngt-1.130356.ch2.txLoad": 70, "network.n2k.ngt-1.130356.ch1.deleted": 0, "network.n2k.ngt-1.130356.ch2.deleted": 0, "network.n2k.ngt-1.130356.ch2Bandwidth": 4, "network.n2k.ngt-1.130356.ch1.bandwidth": 3, "network.n2k.ngt-1.130356.ch1.rxDropped": 0, "network.n2k.ngt-1.130356.ch2.rxDropped": 0, "network.n2k.ngt-1.130356.ch1.rxFiltered": 0, "network.n2k.ngt-1.130356.ch2.rxFiltered": 0, "network.n2k.ngt-1.130356.ch1.rxBandwidth": 4, "network.n2k.ngt-1.130356.ch1.txBandwidth": 0, "network.n2k.ngt-1.130356.ch2.rxBandwidth": 0, "network.n2k.ngt-1.130356.ch2.txBandwidth": 10, "network.n2k.ngt-1.130356.uniChannelCount": 2, "network.n2k.ngt-1.130356.indiChannelCount": 2, "network.n2k.ngt-1.130356.ch1.BufferLoading": 0, "network.n2k.ngt-1.130356.ch2.bufferLoading": 0, "network.n2k.ngt-1.130356.ch1.PointerLoading": 0, "network.n2k.ngt-1.130356.ch2.pointerLoading": 0}
+	},
+	{
+		"time" : "2022-07-31T12:14:29.168Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7124174,
+		"longitude" : 24.7289112,
+		"speedoverground" : 5.7,
+		"courseovergroundtrue" : 197.6,
+		"windspeedapparent" : 15.9,
+		"anglespeedapparent" : 31.0,
+		"status" : "ais-sart",
+		"metrics" : {}
+	},
+	{
+		"time" : "2022-07-31T12:14:29.168Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7124174,
+		"longitude" : 24.7289112,
+		"speedoverground" : 55.7,
+		"courseovergroundtrue" : 197.6,
+		"windspeedapparent" : 15.9,
+		"anglespeedapparent" : 31.0,
+		"status" : "anchored",
+		"metrics" : {}
+	},
+	{
+		"time" : "2022-07-31T12:14:29.168Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:987654321",
+		"latitude" : 59.7124174,
+		"longitude" : 24.7289112,
+		"speedoverground" : 5.7,
+		"courseovergroundtrue" : 197.6,
+		"windspeedapparent" : 15.9,
+		"anglespeedapparent" : 31.0,
+		"status" : "anchored",
+		"metrics" : {}
+	}
+]}

tests/metrics_sample_kapla.json

@@ -0,0 +1,663 @@
+{
+"metrics": [
+	{
+		"time" : "2022-07-30T14:52:28.000Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.077666666666666,
+		"longitude" : 23.530866666666668,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 207.5,
+		"windspeedapparent" : 14.8,
+		"anglespeedapparent" : -12.0,
+		"status" : "moored",
+		"metrics" : {"environment.wind.speedTrue": 4.44, "navigation.speedThroughWater": 3.0918118943701245, "performance.velocityMadeGood": 2.9323340761912995, "environment.wind.angleTrueWater": -0.3665191430024964, "environment.depth.belowTransducer": 13.1, "navigation.courseOverGroundMagnetic": 3.620685534088946, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T14:52:28.000Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.077666666666666,
+		"longitude" : 23.530866666666668,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 207.5,
+		"windspeedapparent" : 14.8,
+		"anglespeedapparent" : -12.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 4.44, "navigation.speedThroughWater": 3.0918118943701245, "performance.velocityMadeGood": 2.9323340761912995, "environment.wind.angleTrueWater": -0.3665191430024964, "environment.depth.belowTransducer": 13.1, "navigation.courseOverGroundMagnetic": 3.620685534088946, "navigation.courseRhumbline.crossTrackError": 0, "propulsion.main.runTime":1776241 }
+	},
+	{
+		"time" : "2022-07-30T14:53:28.000Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.077666666666666,
+		"longitude" : 23.530866666666668,
+		"speedoverground" : 5.7,
+		"courseovergroundtrue" : 207.5,
+		"windspeedapparent" : 14.8,
+		"anglespeedapparent" : -12.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 4.44, "navigation.speedThroughWater": 3.0918118943701245, "performance.velocityMadeGood": 2.9323340761912995, "environment.wind.angleTrueWater": -0.3665191430024964, "environment.depth.belowTransducer": 13.1, "navigation.courseOverGroundMagnetic": 3.620685534088946, "navigation.courseRhumbline.crossTrackError": 0 }
+	},
+	{
+		"time" : "2022-07-30T14:54:28.016Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.07065,
+		"longitude" : 23.52355,
+		"speedoverground" : 5.6,
+		"courseovergroundtrue" : 211.5,
+		"windspeedapparent" : 14.8,
+		"anglespeedapparent" : -7.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 4.52, "navigation.speedThroughWater": 3.0815230028747167, "performance.velocityMadeGood": 2.9683451964252274, "environment.wind.angleTrueWater": -0.20943951028714078, "environment.depth.belowTransducer": 13.58, "navigation.courseOverGroundMagnetic": 3.6910223029603775, "navigation.courseRhumbline.crossTrackError": 0, "propulsion.main.runTime":1776241 }
+	},
+	{
+		"time" : "2022-07-30T14:55:28.021Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.0637,
+		"longitude" : 23.515866666666668,
+		"speedoverground" : 5.6,
+		"courseovergroundtrue" : 211.3,
+		"windspeedapparent" : 15.7,
+		"anglespeedapparent" : 0.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 4.99, "navigation.speedThroughWater": 3.0558007741361966, "performance.velocityMadeGood": 3.00950076240686, "environment.wind.angleTrueWater": 0, "environment.depth.belowTransducer": 16.75, "navigation.courseOverGroundMagnetic": 3.6878807103060707, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T14:56:28.033Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.05671666666667,
+		"longitude" : 23.507866666666665,
+		"speedoverground" : 5.9,
+		"courseovergroundtrue" : 211.1,
+		"windspeedapparent" : 19.8,
+		"anglespeedapparent" : -2.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 4.22, "navigation.speedThroughWater": 3.1895563635765014, "performance.velocityMadeGood": 3.1586896890902767, "environment.wind.angleTrueWater": -0.0174532925239284, "environment.depth.belowTransducer": 18.96, "navigation.courseOverGroundMagnetic": 3.683866453025567, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T14:57:28.049Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.04915,
+		"longitude" : 23.500533333333333,
+		"speedoverground" : 6.1,
+		"courseovergroundtrue" : 212.0,
+		"windspeedapparent" : 14.2,
+		"anglespeedapparent" : -5.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.9, "navigation.speedThroughWater": 3.2204230380627252, "performance.velocityMadeGood": 3.168978580585685, "environment.wind.angleTrueWater": -0.19198621776321237, "environment.depth.belowTransducer": 21.41, "navigation.courseOverGroundMagnetic": 3.6997489492223417, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T14:58:28.064Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.04163333333333,
+		"longitude" : 23.493,
+		"speedoverground" : 6.0,
+		"courseovergroundtrue" : 204.9,
+		"windspeedapparent" : 12.0,
+		"anglespeedapparent" : -26.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 1.93, "navigation.speedThroughWater": 3.2615786040443577, "performance.velocityMadeGood": 0.8025335366418294, "environment.wind.angleTrueWater": -1.30899693929463, "environment.depth.belowTransducer": 21.01, "navigation.courseOverGroundMagnetic": 3.5753069735267324, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T14:59:28.095Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.03398333333333,
+		"longitude" : 23.485466666666667,
+		"speedoverground" : 6.1,
+		"courseovergroundtrue" : 206.0,
+		"windspeedapparent" : 9.5,
+		"anglespeedapparent" : -23.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.29, "navigation.speedThroughWater": 3.2461452668012454, "performance.velocityMadeGood": 1.6668004222561073, "environment.wind.angleTrueWater": -0.9948376738639186, "environment.depth.belowTransducer": 27.74, "navigation.courseOverGroundMagnetic": 3.595203727004011, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:00:28.106Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.02621666666667,
+		"longitude" : 23.479033333333334,
+		"speedoverground" : 6.0,
+		"courseovergroundtrue" : 201.6,
+		"windspeedapparent" : 10.5,
+		"anglespeedapparent" : -8.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.21, "navigation.speedThroughWater": 3.2410008210535413, "performance.velocityMadeGood": 3.0660896656316043, "environment.wind.angleTrueWater": -0.38397243552642474, "environment.depth.belowTransducer": 31.18, "navigation.courseOverGroundMagnetic": 3.518409239898726, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:01:28.107Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.01835,
+		"longitude" : 23.47295,
+		"speedoverground" : 6.0,
+		"courseovergroundtrue" : 197.4,
+		"windspeedapparent" : 10.9,
+		"anglespeedapparent" : -13.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.07, "navigation.speedThroughWater": 3.2461452668012454, "performance.velocityMadeGood": 2.896322955957371, "environment.wind.angleTrueWater": -0.40142572805035315, "environment.depth.belowTransducer": 34.89, "navigation.courseOverGroundMagnetic": 3.445454477148705, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:02:28.118Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.01045,
+		"longitude" : 23.46745,
+		"speedoverground" : 6.0,
+		"courseovergroundtrue" : 201.6,
+		"windspeedapparent" : 12.8,
+		"anglespeedapparent" : -26.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 3.98, "navigation.speedThroughWater": 3.2101341465673174, "performance.velocityMadeGood": 2.263556128989775, "environment.wind.angleTrueWater": -0.8203047486246348, "environment.depth.belowTransducer": 23.33, "navigation.courseOverGroundMagnetic": 3.518060174048247, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:03:28.140Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 60.00351666666667,
+		"longitude" : 23.461033333333333,
+		"speedoverground" : 5.1,
+		"courseovergroundtrue" : 210.5,
+		"windspeedapparent" : 12.0,
+		"anglespeedapparent" : -8.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.34, "navigation.speedThroughWater": 2.69054512604921, "performance.velocityMadeGood": 2.5207784163749767, "environment.wind.angleTrueWater": -0.3665191430024964, "environment.depth.belowTransducer": 18.21, "navigation.courseOverGroundMagnetic": 3.673219944585971, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:04:28.159Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.99755,
+		"longitude" : 23.45415,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 215.7,
+		"windspeedapparent" : 14.4,
+		"anglespeedapparent" : 6.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 4.86, "navigation.speedThroughWater": 2.5670784281043133, "performance.velocityMadeGood": 2.546500645113497, "environment.wind.angleTrueWater": 0.20943951028714078, "environment.depth.belowTransducer": 8.97, "navigation.courseOverGroundMagnetic": 3.765198796187073, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:05:28.169Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.99235,
+		"longitude" : 23.445683333333335,
+		"speedoverground" : 4.7,
+		"courseovergroundtrue" : 225.9,
+		"windspeedapparent" : 16.1,
+		"anglespeedapparent" : -5.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 6.075590428038464, "navigation.speedThroughWater": 2.5053450791318648, "performance.velocityMadeGood": 2.4641895131502323, "environment.wind.angleTrueWater": -0.12217304766749879, "environment.depth.belowTransducer": 7.03, "navigation.courseOverGroundMagnetic": 3.9426987811554253, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:06:28.196Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.989266666666666,
+		"longitude" : 23.438766666666666,
+		"speedoverground" : 1.9,
+		"courseovergroundtrue" : 223.2,
+		"windspeedapparent" : 16.7,
+		"anglespeedapparent" : 3.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 7.61, "navigation.speedThroughWater": 1.0134558122976947, "performance.velocityMadeGood": 0.9825891378114705, "environment.wind.angleTrueWater": 0.052359877571785195, "environment.depth.belowTransducer": 5.78, "navigation.courseOverGroundMagnetic": 3.89522582549034, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:07:28.205Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.98786666666667,
+		"longitude" : 23.435116666666666,
+		"speedoverground" : 1.9,
+		"courseovergroundtrue" : 229.6,
+		"windspeedapparent" : 18.1,
+		"anglespeedapparent" : -5.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 8.02, "navigation.speedThroughWater": 1.0186002580453988, "performance.velocityMadeGood": 0.9620113548206545, "environment.wind.angleTrueWater": -0.19198621776321237, "environment.depth.belowTransducer": 5.33, "navigation.courseOverGroundMagnetic": 4.007799562269678, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:08:28.218Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.986333333333334,
+		"longitude" : 23.43165,
+		"speedoverground" : 1.4,
+		"courseovergroundtrue" : 204.7,
+		"windspeedapparent" : 14.8,
+		"anglespeedapparent" : 4.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 6.3, "navigation.speedThroughWater": 0.745944633417085, "performance.velocityMadeGood": 0.7408001876693809, "environment.wind.angleTrueWater": 0, "environment.depth.belowTransducer": 5.49, "navigation.courseOverGroundMagnetic": 3.5732125784238606, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:09:28.241Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.984833333333334,
+		"longitude" : 23.4292,
+		"speedoverground" : 1.3,
+		"courseovergroundtrue" : 225.8,
+		"windspeedapparent" : 13.4,
+		"anglespeedapparent" : -20.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 4.48, "navigation.speedThroughWater": 0.745944633417085, "performance.velocityMadeGood": 0.7613779706601971, "environment.wind.angleTrueWater": -0.40142572805035315, "environment.depth.belowTransducer": 7.8, "navigation.courseOverGroundMagnetic": 3.9414770506787504, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:10:28.257Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.9862,
+		"longitude" : 23.432566666666666,
+		"speedoverground" : 3.3,
+		"courseovergroundtrue" : 41.1,
+		"windspeedapparent" : 16.1,
+		"anglespeedapparent" : 175.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 9.93, "navigation.speedThroughWater": 1.6205004105267706, "performance.velocityMadeGood": -1.6153559647790667, "environment.wind.angleTrueWater": 3.071779484211398, "environment.depth.belowTransducer": 5.41, "navigation.courseOverGroundMagnetic": 0.7171557898082179, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:11:43.288Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.98726666666666,
+		"longitude" : 23.43375,
+		"speedoverground" : 1.7,
+		"courseovergroundtrue" : 228.8,
+		"windspeedapparent" : 15.7,
+		"anglespeedapparent" : 8.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 6.37, "navigation.speedThroughWater": 0.9825891378114705, "performance.velocityMadeGood": 0.8694113313619818, "environment.wind.angleTrueWater": 0.15707963271535558, "environment.depth.belowTransducer": 5.31, "navigation.courseOverGroundMagnetic": 3.9934878624000567, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:12:58.309Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.98615,
+		"longitude" : 23.431566666666665,
+		"speedoverground" : 1.0,
+		"courseovergroundtrue" : 223.5,
+		"windspeedapparent" : 22.1,
+		"anglespeedapparent" : -6.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 7.63, "navigation.speedThroughWater": 0.6687779472015245, "performance.velocityMadeGood": 0.61218904397678, "environment.wind.angleTrueWater": -0.12217304766749879, "environment.depth.belowTransducer": 5.71, "navigation.courseOverGroundMagnetic": 3.9011599449484757, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:13:58.309Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.98615,
+		"longitude" : 23.431566666666665,
+		"speedoverground" : 1.0,
+		"courseovergroundtrue" : 223.5,
+		"windspeedapparent" : 22.1,
+		"anglespeedapparent" : -6.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 7.63, "navigation.speedThroughWater": 0.6687779472015245, "performance.velocityMadeGood": 0.61218904397678, "environment.wind.angleTrueWater": -0.12217304766749879, "environment.depth.belowTransducer": 5.71, "navigation.courseOverGroundMagnetic": 3.9011599449484757, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:14:28.343Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.98565,
+		"longitude" : 23.4307,
+		"speedoverground" : 1.2,
+		"courseovergroundtrue" : 224.5,
+		"windspeedapparent" : 19.4,
+		"anglespeedapparent" : 2.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 5.83, "navigation.speedThroughWater": 0.7613779706601971, "performance.velocityMadeGood": 0.7150779589308607, "environment.wind.angleTrueWater": -0.29670597290678274, "environment.depth.belowTransducer": 6.44, "navigation.courseOverGroundMagnetic": 3.9177405728462076, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:15:28.366Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.98468333333334,
+		"longitude" : 23.429383333333334,
+		"speedoverground" : 6.1,
+		"courseovergroundtrue" : 219.9,
+		"windspeedapparent" : 13.2,
+		"anglespeedapparent" : 3.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 3.35, "navigation.speedThroughWater": 3.4622119882048152, "performance.velocityMadeGood": 3.32845639876451, "environment.wind.angleTrueWater": 0, "environment.depth.belowTransducer": 8.07, "navigation.courseOverGroundMagnetic": 3.837455427236137, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:16:28.373Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.978233333333336,
+		"longitude" : 23.42106666666667,
+		"speedoverground" : 5.3,
+		"courseovergroundtrue" : 216.7,
+		"windspeedapparent" : 15.3,
+		"anglespeedapparent" : -8.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 4.93, "navigation.speedThroughWater": 2.9632007506775238, "performance.velocityMadeGood": 2.772856258012474, "environment.wind.angleTrueWater": -0.20943951028714078, "environment.depth.belowTransducer": 5.16, "navigation.courseOverGroundMagnetic": 3.7824775557857624, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:17:28.386Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.977716666666666,
+		"longitude" : 23.431,
+		"speedoverground" : 2.1,
+		"courseovergroundtrue" : 151.9,
+		"windspeedapparent" : 12.8,
+		"anglespeedapparent" : 32.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.74, "navigation.speedThroughWater": 1.1214891729994796, "performance.velocityMadeGood": 0.2520778416374977, "environment.wind.angleTrueWater": 1.5533430346296275, "environment.depth.belowTransducer": 3.49, "navigation.courseOverGroundMagnetic": 2.6518532660856806, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:18:28.434Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.97688333333333,
+		"longitude" : 23.432133333333333,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 179.3,
+		"windspeedapparent" : 11.1,
+		"anglespeedapparent" : 88.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 3.1895563635765014, "navigation.speedThroughWater": 0, "performance.velocityMadeGood": 0, "environment.wind.angleTrueWater": 1.8151424224885533, "environment.depth.belowTransducer": 1.67, "navigation.courseOverGroundMagnetic": 3.1290262836898832, "navigation.courseRhumbline.crossTrackError": 0 }
+	},
+	{
+		"time" : "2022-07-30T15:19:28.467Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.97688333333333,
+		"longitude" : 23.4321,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 241.0,
+		"windspeedapparent" : 4.3,
+		"anglespeedapparent" : 74.0,
+		"status" : "moored",
+		"metrics" : {"environment.wind.speedTrue": 0, "navigation.speedThroughWater": 0, "performance.velocityMadeGood": 0, "environment.wind.angleTrueWater": 0.7853981635767779, "environment.depth.belowTransducer": 1.65, "navigation.courseOverGroundMagnetic": 4.206068965341505, "navigation.courseRhumbline.crossTrackError": 0, "propulsion.main.runTime":1776251}
+	},
+	{
+		"time" : "2022-07-30T15:20:28.467Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.97688333333333,
+		"longitude" : 23.4321,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 241.0,
+		"windspeedapparent" : 4.3,
+		"anglespeedapparent" : 74.0,
+		"status" : "moored",
+		"metrics" : {"environment.wind.speedTrue": 0, "navigation.speedThroughWater": 0, "performance.velocityMadeGood": 0, "environment.wind.angleTrueWater": 0.7853981635767779, "environment.depth.belowTransducer": 1.65, "navigation.courseOverGroundMagnetic": 4.206068965341505, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:20:28.467Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.97688333333333,
+		"longitude" : 23.4321,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 241.0,
+		"windspeedapparent" : 4.3,
+		"anglespeedapparent" : 74.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0, "navigation.speedThroughWater": 0, "performance.velocityMadeGood": 0, "environment.wind.angleTrueWater": 0.7853981635767779, "environment.depth.belowTransducer": 1.65, "navigation.courseOverGroundMagnetic": 4.206068965341505, "navigation.courseRhumbline.crossTrackError": 0, "propulsion.main.runTime":1776251}
+	},
+	{
+		"time" : "2022-07-30T15:21:28.467Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.97688333333333,
+		"longitude" : 23.4321,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 241.0,
+		"windspeedapparent" : 4.3,
+		"anglespeedapparent" : 74.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0, "navigation.speedThroughWater": 0, "performance.velocityMadeGood": 0, "environment.wind.angleTrueWater": 0.7853981635767779, "environment.depth.belowTransducer": 1.65, "navigation.courseOverGroundMagnetic": 4.206068965341505, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:22:28.479Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.9781,
+		"longitude" : 23.425533333333334,
+		"speedoverground" : 5.0,
+		"courseovergroundtrue" : 258.3,
+		"windspeedapparent" : 9.1,
+		"anglespeedapparent" : 11.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.24, "navigation.speedThroughWater": 2.577367319599721, "performance.velocityMadeGood": 2.3561561524484476, "environment.wind.angleTrueWater": 0.41887902057428156, "environment.depth.belowTransducer": 5.05, "navigation.courseOverGroundMagnetic": 4.507661860154987, "navigation.courseRhumbline.crossTrackError": 0, "propulsion.main.runTime": 1776251}
+	},
+	{
+		"time" : "2022-07-30T15:23:28.492Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.9738,
+		"longitude" : 23.41165,
+		"speedoverground" : 6.2,
+		"courseovergroundtrue" : 228.0,
+		"windspeedapparent" : 11.8,
+		"anglespeedapparent" : 12.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.92, "navigation.speedThroughWater": 3.194700809324205, "performance.velocityMadeGood": 2.5207784163749767, "environment.wind.angleTrueWater": 0.8028514561007063, "environment.depth.belowTransducer": 5.44, "navigation.courseOverGroundMagnetic": 3.9854593478390496, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:24:28.498Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.967,
+		"longitude" : 23.40138333333333,
+		"speedoverground" : 6.1,
+		"courseovergroundtrue" : 197.7,
+		"windspeedapparent" : 10.9,
+		"anglespeedapparent" : 16.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.99, "navigation.speedThroughWater": 3.215278592315021, "performance.velocityMadeGood": 1.2964003284214165, "environment.wind.angleTrueWater": 1.274090354246773, "environment.depth.belowTransducer": 5.74, "navigation.courseOverGroundMagnetic": 3.4508649978311228, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:25:28.540Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.958866666666665,
+		"longitude" : 23.395816666666665,
+		"speedoverground" : 6.2,
+		"courseovergroundtrue" : 203.9,
+		"windspeedapparent" : 10.5,
+		"anglespeedapparent" : 38.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 3.44, "navigation.speedThroughWater": 3.215278592315021, "performance.velocityMadeGood": 1.512467049824986, "environment.wind.angleTrueWater": 1.2566370617228446, "environment.depth.belowTransducer": 7.13, "navigation.courseOverGroundMagnetic": 3.5587263456290006, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:26:28.572Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.9508,
+		"longitude" : 23.390166666666666,
+		"speedoverground" : 6.2,
+		"courseovergroundtrue" : 200.6,
+		"windspeedapparent" : 12.0,
+		"anglespeedapparent" : 63.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 4.12, "navigation.speedThroughWater": 3.2461452668012454, "performance.velocityMadeGood": -1.3787114603846813, "environment.wind.angleTrueWater": 1.884955592584267, "environment.depth.belowTransducer": 8.6, "navigation.courseOverGroundMagnetic": 3.5004323485990794, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:27:28.599Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.94275,
+		"longitude" : 23.38365,
+		"speedoverground" : 6.3,
+		"courseovergroundtrue" : 206.9,
+		"windspeedapparent" : 7.8,
+		"anglespeedapparent" : 22.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 2.13, "navigation.speedThroughWater": 3.2255674838104293, "performance.velocityMadeGood": -1.1317780644948876, "environment.wind.angleTrueWater": 1.9373154701560522, "environment.depth.belowTransducer": 12.98, "navigation.courseOverGroundMagnetic": 3.6112607561260246, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:28:28.606Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.93578333333333,
+		"longitude" : 23.37245,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 227.5,
+		"windspeedapparent" : 7.6,
+		"anglespeedapparent" : -10.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 1.12, "navigation.speedThroughWater": 3.2307119295581335, "performance.velocityMadeGood": -2.896322955957371, "environment.wind.angleTrueWater": -2.7750735113046154, "environment.depth.belowTransducer": 11.7, "navigation.courseOverGroundMagnetic": 3.9704495162684714, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:29:28.619Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.93076666666666,
+		"longitude" : 23.3572,
+		"speedoverground" : 6.3,
+		"courseovergroundtrue" : 232.5,
+		"windspeedapparent" : 6.8,
+		"anglespeedapparent" : 19.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.92, "navigation.speedThroughWater": 3.2307119295581335, "performance.velocityMadeGood": -1.960033829875237, "environment.wind.angleTrueWater": 2.2165681505389068, "environment.depth.belowTransducer": 14.23, "navigation.courseOverGroundMagnetic": 4.05858864351431, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:30:28.637Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.925133333333335,
+		"longitude" : 23.3448,
+		"speedoverground" : 5.9,
+		"courseovergroundtrue" : 228.4,
+		"windspeedapparent" : 7.2,
+		"anglespeedapparent" : 13.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.82, "navigation.speedThroughWater": 3.2358563753058376, "performance.velocityMadeGood": -2.1246560938017662, "environment.wind.angleTrueWater": 2.373647783254262, "environment.depth.belowTransducer": 14.29, "navigation.courseOverGroundMagnetic": 3.986855611240964, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:31:28.668Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.918933333333335,
+		"longitude" : 23.33415,
+		"speedoverground" : 6.0,
+		"courseovergroundtrue" : 211.6,
+		"windspeedapparent" : 6.4,
+		"anglespeedapparent" : -15.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.86, "navigation.speedThroughWater": 3.2255674838104293, "performance.velocityMadeGood": -0.38068898533009854, "environment.wind.angleTrueWater": -1.7278759598689115, "environment.depth.belowTransducer": 18.1, "navigation.courseOverGroundMagnetic": 3.6927676322127705, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:32:28.735Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.9114,
+		"longitude" : 23.32743333333333,
+		"speedoverground" : 6.2,
+		"courseovergroundtrue" : 175.6,
+		"windspeedapparent" : 6.4,
+		"anglespeedapparent" : -8.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.36, "navigation.speedThroughWater": 3.199845255071909, "performance.velocityMadeGood": -0.3189556363576501, "environment.wind.angleTrueWater": -1.6057029122014126, "environment.depth.belowTransducer": 10.95, "navigation.courseOverGroundMagnetic": 3.064972700127066, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:33:28.757Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.90315,
+		"longitude" : 23.329966666666667,
+		"speedoverground" : 6.1,
+		"courseovergroundtrue" : 144.0,
+		"windspeedapparent" : 5.8,
+		"anglespeedapparent" : -3.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.24, "navigation.speedThroughWater": 3.2049897008196133, "performance.velocityMadeGood": -2.4847672961410483, "environment.wind.angleTrueWater": -2.3911010757781903, "environment.depth.belowTransducer": 13.92, "navigation.courseOverGroundMagnetic": 2.512575991744732, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:34:28.787Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.89735,
+		"longitude" : 23.3428,
+		"speedoverground" : 6.3,
+		"courseovergroundtrue" : 129.8,
+		"windspeedapparent" : 5.2,
+		"anglespeedapparent" : -2.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 1, "navigation.speedThroughWater": 3.2307119295581335, "performance.velocityMadeGood": -3.1895563635765014, "environment.wind.angleTrueWater": -2.932153144019971, "environment.depth.belowTransducer": 11.32, "navigation.courseOverGroundMagnetic": 2.265960968381624, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:35:28.798Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.88953333333333,
+		"longitude" : 23.3492,
+		"speedoverground" : 6.5,
+		"courseovergroundtrue" : 162.5,
+		"windspeedapparent" : 7.2,
+		"anglespeedapparent" : -7.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.95, "navigation.speedThroughWater": 3.199845255071909, "performance.velocityMadeGood": -3.050656328388492, "environment.wind.angleTrueWater": -2.844886681400329, "environment.depth.belowTransducer": 10.04, "navigation.courseOverGroundMagnetic": 2.8354619034374076, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:36:28.812Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.88126666666667,
+		"longitude" : 23.345833333333335,
+		"speedoverground" : 6.1,
+		"courseovergroundtrue" : 196.5,
+		"windspeedapparent" : 8.7,
+		"anglespeedapparent" : -15.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.87, "navigation.speedThroughWater": 3.199845255071909, "performance.velocityMadeGood": -1.1832225219719277, "environment.wind.angleTrueWater": -1.972222055203909, "environment.depth.belowTransducer": 22.3, "navigation.courseOverGroundMagnetic": 3.429921046802409, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:37:28.835Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.87278333333333,
+		"longitude" : 23.344066666666667,
+		"speedoverground" : 6.2,
+		"courseovergroundtrue" : 160.5,
+		"windspeedapparent" : 7.8,
+		"anglespeedapparent" : -5.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.57, "navigation.speedThroughWater": 3.174123026333389, "performance.velocityMadeGood": 2.870600727218851, "environment.wind.angleTrueWater": -0.261799387858926, "environment.depth.belowTransducer": 24.73, "navigation.courseOverGroundMagnetic": 2.8016025159409867, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:38:28.838Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.866616666666665,
+		"longitude" : 23.355716666666666,
+		"speedoverground" : 6.1,
+		"courseovergroundtrue" : 131.4,
+		"windspeedapparent" : 35.8,
+		"anglespeedapparent" : 9.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.51, "navigation.speedThroughWater": 3.2255674838104293, "performance.velocityMadeGood": -1.347844785898457, "environment.wind.angleTrueWater": 1.7453292523928399, "environment.depth.belowTransducer": 9.85, "navigation.courseOverGroundMagnetic": 2.292489973017995, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:39:28.867Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.86,
+		"longitude" : 23.365766666666666,
+		"speedoverground" : 5.8,
+		"courseovergroundtrue" : 122.0,
+		"windspeedapparent" : 37.2,
+		"anglespeedapparent" : 10.0,
+		"status" : "sailing",
+		"metrics" : {"environment.wind.speedTrue": 0.63, "navigation.speedThroughWater": 3.2255674838104293, "performance.velocityMadeGood": -2.242978345998959, "environment.wind.angleTrueWater": 2.3038346131585485, "environment.depth.belowTransducer": 17.73, "navigation.courseOverGroundMagnetic": 2.129127154994025, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:40:28.867Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.86,
+		"longitude" : 23.365766666666666,
+		"speedoverground" : 4.5,
+		"courseovergroundtrue" : 122.0,
+		"windspeedapparent" : 7.2,
+		"anglespeedapparent" : 10.0,
+		"status" : "anchored",
+		"metrics" : {"environment.wind.speedTrue": 0.63, "navigation.speedThroughWater": 3.2255674838104293, "performance.velocityMadeGood": -2.242978345998959, "environment.wind.angleTrueWater": 2.3038346131585485, "environment.depth.belowTransducer": 17.73, "navigation.courseOverGroundMagnetic": 2.129127154994025, "navigation.courseRhumbline.crossTrackError": 0, "propulsion.main.runTime":1776262}
+	},
+	{
+		"time" : "2022-07-30T15:41:28.867Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.86,
+		"longitude" : 23.365766666666666,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 122.0,
+		"windspeedapparent" : 7.2,
+		"anglespeedapparent" : 10.0,
+		"status" : "anchored",
+		"metrics" : {"environment.wind.speedTrue": 0.63, "navigation.speedThroughWater": 3.2255674838104293, "performance.velocityMadeGood": -2.242978345998959, "environment.wind.angleTrueWater": 2.3038346131585485, "environment.depth.belowTransducer": 17.73, "navigation.courseOverGroundMagnetic": 2.129127154994025, "navigation.courseRhumbline.crossTrackError": 0}
+	},
+	{
+		"time" : "2022-07-30T15:41:28.867Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.86,
+		"longitude" : 23.365766666666666,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 122.0,
+		"windspeedapparent" : 7.2,
+		"anglespeedapparent" : 10.0,
+		"status" : "unknown",
+		"metrics" : {}
+	},
+	{
+		"time" : "2022-07-30T15:41:28.867Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.86,
+		"longitude" : 23.365766666666666,
+		"speedoverground" : 60.0,
+		"courseovergroundtrue" : 122.0,
+		"windspeedapparent" : 7.2,
+		"anglespeedapparent" : 10.0,
+		"status" : "anchored",
+		"metrics" : {}
+	},
+	{
+		"time" : "2022-07-30T15:41:28.867Z",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:123456789",
+		"latitude" : 59.86,
+		"longitude" : 23.365766666666666,
+		"speedoverground" : 0.0,
+		"courseovergroundtrue" : 122.0,
+		"windspeedapparent" : 7.2,
+		"anglespeedapparent" : 10.0,
+		"status" : "anchored",
+		"metrics" : {}
+	}
+]}

tests/metrics_sample_simulator.json

@@ -0,0 +1,879 @@
+{
+ "metrics": [
+	{
+		"time" : "2022-12-13 20:39:04.562",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.3786471,
+		"longitude" : 2.277667383333333,
+		"speedoverground" : 4.1,
+		"courseovergroundtrue" : 17.4,
+		"windspeedapparent" : 8.1,
+		"anglespeedapparent" : -32.3,
+		"status" : "moored",
+		"metrics" : {"navigation.headingTrue": 0.3036872899163541, "environment.wind.speedTrue": 1.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.3036872899163541, "environment.depth.belowKeel": 9.3, "navigation.speedThroughWater": 2.109222756558654, "environment.water.temperature": 280.75, "environment.depth.belowSurface": 9.3, "environment.wind.directionTrue": 5.223770452411769, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 0, "propulsion.engine_2.revolutions": 0, "environment.depth.belowTransducer": 9.3, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 5.223770452411769, "navigation.gnss.horizontalDilution": 1.8, "navigation.courseOverGroundMagnetic": 0.3036872899163541, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670963929}
+	},
+	{
+		"time" : "2022-12-13 20:40:04.568",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.37983186666666,
+		"longitude" : 2.2781615333333334,
+		"speedoverground" : 4.1,
+		"courseovergroundtrue" : 16.5,
+		"windspeedapparent" : 6.0,
+		"anglespeedapparent" : -25.2,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.28797932664481857, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.28797932664481857, "environment.depth.belowKeel": 11.8, "navigation.speedThroughWater": 2.109222756558654, "environment.water.temperature": 280.95, "environment.depth.belowSurface": 11.8, "environment.wind.directionTrue": 5.483824511018303, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 0, "propulsion.engine_2.revolutions": 0, "environment.depth.belowTransducer": 11.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 5.483824511018303, "navigation.gnss.horizontalDilution": 1.7, "navigation.courseOverGroundMagnetic": 0.28797932664481857, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670963985}
+	},
+	{
+		"time" : "2022-12-13 20:41:04.592",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.380872266666664,
+		"longitude" : 2.2785093333333335,
+		"speedoverground" : 4.1,
+		"courseovergroundtrue" : 13.6,
+		"windspeedapparent" : 7.2,
+		"anglespeedapparent" : -34.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.2373647783254262, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.2373647783254262, "environment.depth.belowKeel": 10.7, "navigation.speedThroughWater": 2.109222756558654, "environment.water.temperature": 281.15, "environment.depth.belowSurface": 10.7, "environment.wind.directionTrue": 4.974188369319593, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 0, "propulsion.engine_2.revolutions": 0, "environment.depth.belowTransducer": 10.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 4.974188369319593, "navigation.gnss.horizontalDilution": 1.3, "navigation.courseOverGroundMagnetic": 0.2373647783254262, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964045}
+	},
+	{
+		"time" : "2022-12-13 20:42:04.609",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.38208281666667,
+		"longitude" : 2.2788272,
+		"speedoverground" : 4.2,
+		"courseovergroundtrue" : 10.7,
+		"windspeedapparent" : 10.0,
+		"anglespeedapparent" : -39.2,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.18675023000603386, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.18675023000603386, "environment.depth.belowKeel": 12.4, "navigation.speedThroughWater": 2.1606672140356946, "environment.water.temperature": 281.15, "environment.depth.belowSurface": 12.4, "environment.wind.directionTrue": 5.223770452411769, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10, "propulsion.engine_2.revolutions": 10, "environment.depth.belowTransducer": 12.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 5.223770452411769, "navigation.gnss.horizontalDilution": 1.6, "navigation.courseOverGroundMagnetic": 0.18675023000603386, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964109}
+	},
+	{
+		"time" : "2022-12-13 20:43:04.645",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.383208116666665,
+		"longitude" : 2.2791273833333334,
+		"speedoverground" : 4.1,
+		"courseovergroundtrue" : 11.2,
+		"windspeedapparent" : 6.5,
+		"anglespeedapparent" : -10.8,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.19547687626799803, "environment.wind.speedTrue": 1.2, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.19547687626799803, "environment.depth.belowKeel": 14.4, "navigation.speedThroughWater": 2.109222756558654, "environment.water.temperature": 280.95, "environment.depth.belowSurface": 14.4, "environment.wind.directionTrue": 5.967280713931119, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.403333333333334, "propulsion.engine_2.revolutions": 10.2, "environment.depth.belowTransducer": 14.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 5.967280713931119, "navigation.gnss.horizontalDilution": 1.7, "navigation.courseOverGroundMagnetic": 0.19547687626799803, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964164}
+	},
+	{
+		"time" : "2022-12-13 20:44:04.683",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.38424145,
+		"longitude" : 2.27946345,
+		"speedoverground" : 4.2,
+		"courseovergroundtrue" : 13.6,
+		"windspeedapparent" : 7.0,
+		"anglespeedapparent" : -12.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.2373647783254262, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.2373647783254262, "environment.depth.belowKeel": 11.8, "navigation.speedThroughWater": 2.1606672140356946, "environment.water.temperature": 280.95, "environment.depth.belowSurface": 11.8, "environment.wind.directionTrue": 5.967280713931119, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.403333333333334, "propulsion.engine_2.revolutions": 10, "environment.depth.belowTransducer": 11.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 5.967280713931119, "navigation.gnss.horizontalDilution": 1.3, "navigation.courseOverGroundMagnetic": 0.2373647783254262, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964225}
+	},
+	{
+		"time" : "2022-12-13 20:45:04.722",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.385386716666666,
+		"longitude" : 2.2798840166666667,
+		"speedoverground" : 4.2,
+		"courseovergroundtrue" : 15.8,
+		"windspeedapparent" : 5.2,
+		"anglespeedapparent" : -34.4,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.2757620218780687, "environment.wind.speedTrue": 1.2, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.2757620218780687, "environment.depth.belowKeel": 15.1, "navigation.speedThroughWater": 2.1606672140356946, "environment.water.temperature": 280.75, "environment.depth.belowSurface": 15.1, "environment.wind.directionTrue": 4.241150083314601, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.2, "propulsion.engine_2.revolutions": 11.04, "environment.depth.belowTransducer": 15.1, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 4.241150083314601, "navigation.gnss.horizontalDilution": 1.2, "navigation.courseOverGroundMagnetic": 0.2757620218780687, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964290}
+	},
+	{
+		"time" : "2022-12-13 20:46:04.743",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.38658911666667,
+		"longitude" : 2.2802688166666667,
+		"speedoverground" : 4.6,
+		"courseovergroundtrue" : 13.6,
+		"windspeedapparent" : 2.8,
+		"anglespeedapparent" : 166.2,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.2373647783254262, "environment.wind.speedTrue": 3.1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.2373647783254262, "environment.depth.belowKeel": 10.7, "navigation.speedThroughWater": 2.3664450439438554, "environment.water.temperature": 280.54999999999995, "environment.depth.belowSurface": 10.7, "environment.wind.directionTrue": 3.323106896555967, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.2, "propulsion.engine_2.revolutions": 10.403333333333334, "environment.depth.belowTransducer": 10.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 3.323106896555967, "navigation.gnss.horizontalDilution": 1.5, "navigation.courseOverGroundMagnetic": 0.2373647783254262, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964355}
+	},
+	{
+		"time" : "2022-12-13 20:47:04.759",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.387908966666664,
+		"longitude" : 2.2806784166666665,
+		"speedoverground" : 4.6,
+		"courseovergroundtrue" : 13.6,
+		"windspeedapparent" : 8.2,
+		"anglespeedapparent" : 138.2,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.2373647783254262, "environment.wind.speedTrue": 4.4, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.2373647783254262, "environment.depth.belowKeel": 9.7, "navigation.speedThroughWater": 2.3664450439438554, "environment.water.temperature": 280.25, "environment.depth.belowSurface": 9.7, "environment.wind.directionTrue": 3.0141836188824342, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 10.403333333333334, "environment.depth.belowTransducer": 9.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 3.0141836188824342, "navigation.gnss.horizontalDilution": 1.5, "navigation.courseOverGroundMagnetic": 0.2373647783254262, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964414}
+	},
+	{
+		"time" : "2022-12-13 20:48:04.770",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.389180233333335,
+		"longitude" : 2.28109,
+		"speedoverground" : 4.7,
+		"courseovergroundtrue" : 15.0,
+		"windspeedapparent" : 3.6,
+		"anglespeedapparent" : 60.8,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.261799387858926, "environment.wind.speedTrue": 2.1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.261799387858926, "environment.depth.belowKeel": 8.8, "navigation.speedThroughWater": 2.417889501420896, "environment.water.temperature": 279.84999999999997, "environment.depth.belowSurface": 8.8, "environment.wind.directionTrue": 2.733185609247187, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.2, "propulsion.engine_2.revolutions": 10.2, "environment.depth.belowTransducer": 8.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 2.733185609247187, "navigation.gnss.horizontalDilution": 1.7, "navigation.courseOverGroundMagnetic": 0.261799387858926, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964474}
+	},
+	{
+		"time" : "2022-12-13 20:49:04.782",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.39048306666667,
+		"longitude" : 2.28150255,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 12.3,
+		"windspeedapparent" : 5.2,
+		"anglespeedapparent" : 27.3,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.21467549804431932, "environment.wind.speedTrue": 1.2, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.21467549804431932, "environment.depth.belowKeel": 7.3, "navigation.speedThroughWater": 2.4693339588979364, "environment.water.temperature": 280.04999999999995, "environment.depth.belowSurface": 7.3, "environment.wind.directionTrue": 1.8500490075364102, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.486666666666668, "propulsion.engine_2.revolutions": 10.611666666666668, "environment.depth.belowTransducer": 7.3, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.8500490075364102, "navigation.gnss.horizontalDilution": 2, "navigation.courseOverGroundMagnetic": 0.21467549804431932, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964534}
+	},
+	{
+		"time" : "2022-12-13 20:50:04.811",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.3917979,
+		"longitude" : 2.28186645,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 10.2,
+		"windspeedapparent" : 8.3,
+		"anglespeedapparent" : 35.3,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.17802358374406965, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.17802358374406965, "environment.depth.belowKeel": 4.9, "navigation.speedThroughWater": 2.4693339588979364, "environment.water.temperature": 280.54999999999995, "environment.depth.belowSurface": 4.9, "environment.wind.directionTrue": 1.380555438642736, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 10, "environment.depth.belowTransducer": 4.9, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.380555438642736, "navigation.gnss.horizontalDilution": 2.3, "navigation.courseOverGroundMagnetic": 0.17802358374406965, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964595}
+	},
+	{
+		"time" : "2022-12-13 20:51:04.862",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.39308273333333,
+		"longitude" : 2.2821629833333335,
+		"speedoverground" : 5.0,
+		"courseovergroundtrue" : 10.2,
+		"windspeedapparent" : 8.6,
+		"anglespeedapparent" : 34.5,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.17802358374406965, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.17802358374406965, "environment.depth.belowKeel": 3.7, "navigation.speedThroughWater": 2.572222873852017, "environment.water.temperature": 280.65, "environment.depth.belowSurface": 3.7, "environment.wind.directionTrue": 1.380555438642736, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.486666666666668, "propulsion.engine_2.revolutions": 10.2, "environment.depth.belowTransducer": 3.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.380555438642736, "navigation.gnss.horizontalDilution": 2.3, "navigation.courseOverGroundMagnetic": 0.17802358374406965, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964654}
+	},
+	{
+		"time" : "2022-12-13 20:52:04.904",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.394408983333335,
+		"longitude" : 2.2825271833333334,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 11.2,
+		"windspeedapparent" : 9.5,
+		"anglespeedapparent" : 46.9,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.19547687626799803, "environment.wind.speedTrue": 3.7, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.19547687626799803, "environment.depth.belowKeel": 4.5, "navigation.speedThroughWater": 2.4693339588979364, "environment.water.temperature": 280.34999999999997, "environment.depth.belowSurface": 4.5, "environment.wind.directionTrue": 1.5219271080865564, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 10.403333333333334, "environment.depth.belowTransducer": 4.5, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.5219271080865564, "navigation.gnss.horizontalDilution": 2.3, "navigation.courseOverGroundMagnetic": 0.19547687626799803, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964714}
+	},
+	{
+		"time" : "2022-12-13 20:53:04.922",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.39573106666667,
+		"longitude" : 2.2829267166666667,
+		"speedoverground" : 4.9,
+		"courseovergroundtrue" : 12.3,
+		"windspeedapparent" : 10.2,
+		"anglespeedapparent" : 42.4,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.21467549804431932, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.21467549804431932, "environment.depth.belowKeel": 4.5, "navigation.speedThroughWater": 2.5207784163749767, "environment.water.temperature": 280.65, "environment.depth.belowSurface": 4.5, "environment.wind.directionTrue": 1.679006740801912, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 10, "environment.depth.belowTransducer": 4.5, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.679006740801912, "navigation.gnss.horizontalDilution": 3.4, "navigation.courseOverGroundMagnetic": 0.21467549804431932, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964775}
+	},
+	{
+		"time" : "2022-12-13 20:54:04.947",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.39700681666667,
+		"longitude" : 2.2833958666666665,
+		"speedoverground" : 4.9,
+		"courseovergroundtrue" : 16.5,
+		"windspeedapparent" : 8.0,
+		"anglespeedapparent" : 35.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.28797932664481857, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.28797932664481857, "environment.depth.belowKeel": 4.9, "navigation.speedThroughWater": 2.5207784163749767, "environment.water.temperature": 280.65, "environment.depth.belowSurface": 4.9, "environment.wind.directionTrue": 1.5219271080865564, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 10, "environment.depth.belowTransducer": 4.9, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.5219271080865564, "navigation.gnss.horizontalDilution": 4.4, "navigation.courseOverGroundMagnetic": 0.28797932664481857, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964835}
+	},
+	{
+		"time" : "2022-12-13 20:55:04.978",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.39837505,
+		"longitude" : 2.283934583333333,
+		"speedoverground" : 4.9,
+		"courseovergroundtrue" : 16.5,
+		"windspeedapparent" : 9.4,
+		"anglespeedapparent" : 27.9,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.28797932664481857, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.28797932664481857, "environment.depth.belowKeel": 6, "navigation.speedThroughWater": 2.5207784163749767, "environment.water.temperature": 280.65, "environment.depth.belowSurface": 6, "environment.wind.directionTrue": 1.253146403218059, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 10.2, "environment.depth.belowTransducer": 6, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.253146403218059, "navigation.gnss.horizontalDilution": 4.7, "navigation.courseOverGroundMagnetic": 0.28797932664481857, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964895}
+	},
+	{
+		"time" : "2022-12-13 20:56:04.996",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.39972915,
+		"longitude" : 2.2844581333333336,
+		"speedoverground" : 5.2,
+		"courseovergroundtrue" : 16.5,
+		"windspeedapparent" : 10.3,
+		"anglespeedapparent" : 23.8,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.28797932664481857, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.28797932664481857, "environment.depth.belowKeel": 5.4, "navigation.speedThroughWater": 2.675111788806098, "environment.water.temperature": 280.84999999999997, "environment.depth.belowSurface": 5.4, "environment.wind.directionTrue": 1.1362093433077387, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.486666666666668, "propulsion.engine_2.revolutions": 10.2, "environment.depth.belowTransducer": 5.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.1362093433077387, "navigation.gnss.horizontalDilution": 3.8, "navigation.courseOverGroundMagnetic": 0.28797932664481857, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670964954}
+	},
+	{
+		"time" : "2022-12-13 20:57:05.017",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.401043683333334,
+		"longitude" : 2.284932,
+		"speedoverground" : 5.3,
+		"courseovergroundtrue" : 15.0,
+		"windspeedapparent" : 14.3,
+		"anglespeedapparent" : 33.6,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.261799387858926, "environment.wind.speedTrue": 5.3, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.261799387858926, "environment.depth.belowKeel": 4.9, "navigation.speedThroughWater": 2.726556246283138, "environment.water.temperature": 280.65, "environment.depth.belowSurface": 4.9, "environment.wind.directionTrue": 1.1362093433077387, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 10.2, "environment.depth.belowTransducer": 4.9, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.1362093433077387, "navigation.gnss.horizontalDilution": 3.8, "navigation.courseOverGroundMagnetic": 0.261799387858926, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965014}
+	},
+	{
+		"time" : "2022-12-13 20:58:05.043",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.40248723333333,
+		"longitude" : 2.2853501666666665,
+		"speedoverground" : 5.2,
+		"courseovergroundtrue" : 11.2,
+		"windspeedapparent" : 25.2,
+		"anglespeedapparent" : 36.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.19547687626799803, "environment.wind.speedTrue": 7.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.19547687626799803, "environment.depth.belowKeel": 5.4, "navigation.speedThroughWater": 2.675111788806098, "environment.water.temperature": 280.65, "environment.depth.belowSurface": 5.4, "environment.wind.directionTrue": 1.0297442589117756, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.2, "propulsion.engine_2.revolutions": 10.2, "environment.depth.belowTransducer": 5.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.0297442589117756, "navigation.gnss.horizontalDilution": 4.4, "navigation.courseOverGroundMagnetic": 0.19547687626799803, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965075}
+	},
+	{
+		"time" : "2022-12-13 20:59:05.063",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.40396921666667,
+		"longitude" : 2.28573555,
+		"speedoverground" : 5.6,
+		"courseovergroundtrue" : 10.2,
+		"windspeedapparent" : 14.6,
+		"anglespeedapparent" : 27.6,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.17802358374406965, "environment.wind.speedTrue": 3.7, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.17802358374406965, "environment.depth.belowKeel": 5.4, "navigation.speedThroughWater": 2.8808896187142587, "environment.water.temperature": 280.65, "environment.depth.belowSurface": 5.4, "environment.wind.directionTrue": 1.0297442589117756, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.825, "propulsion.engine_2.revolutions": 10.611666666666668, "environment.depth.belowTransducer": 5.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.0297442589117756, "navigation.gnss.horizontalDilution": 4.4, "navigation.courseOverGroundMagnetic": 0.17802358374406965, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965135}
+	},
+	{
+		"time" : "2022-12-13 21:00:05.096",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.40549068333333,
+		"longitude" : 2.2861892666666668,
+		"speedoverground" : 5.5,
+		"courseovergroundtrue" : 13.6,
+		"windspeedapparent" : 15.4,
+		"anglespeedapparent" : 20.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.2373647783254262, "environment.wind.speedTrue": 5.3, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.2373647783254262, "environment.depth.belowKeel": 4.9, "navigation.speedThroughWater": 2.829445161237219, "environment.water.temperature": 280.65, "environment.depth.belowSurface": 4.9, "environment.wind.directionTrue": 0.7696902003052424, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.403333333333334, "propulsion.engine_2.revolutions": 10.825, "environment.depth.belowTransducer": 4.9, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.7696902003052424, "navigation.gnss.horizontalDilution": 4.7, "navigation.courseOverGroundMagnetic": 0.2373647783254262, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965195}
+	},
+	{
+		"time" : "2022-12-13 21:01:05.130",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.406966833333335,
+		"longitude" : 2.2866105,
+		"speedoverground" : 5.5,
+		"courseovergroundtrue" : 10.2,
+		"windspeedapparent" : 19.4,
+		"anglespeedapparent" : 24.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.17802358374406965, "environment.wind.speedTrue": 3.7, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.17802358374406965, "environment.depth.belowKeel": 4.5, "navigation.speedThroughWater": 2.829445161237219, "environment.water.temperature": 280.54999999999995, "environment.depth.belowSurface": 4.5, "environment.wind.directionTrue": 0.9337511500301693, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10, "propulsion.engine_2.revolutions": 12.19, "environment.depth.belowTransducer": 4.5, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.9337511500301693, "navigation.gnss.horizontalDilution": 5, "navigation.courseOverGroundMagnetic": 0.17802358374406965, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965255}
+	},
+	{
+		"time" : "2022-12-13 21:02:05.156",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.40843818333333,
+		"longitude" : 2.2869834833333336,
+		"speedoverground" : 5.3,
+		"courseovergroundtrue" : 10.2,
+		"windspeedapparent" : 14.6,
+		"anglespeedapparent" : 29.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.17802358374406965, "environment.wind.speedTrue": 5.3, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.17802358374406965, "environment.depth.belowKeel": 4.9, "navigation.speedThroughWater": 2.726556246283138, "environment.water.temperature": 280.25, "environment.depth.belowSurface": 4.9, "environment.wind.directionTrue": 0.9337511500301693, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.825, "propulsion.engine_2.revolutions": 11.716666666666667, "environment.depth.belowTransducer": 4.9, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.9337511500301693, "navigation.gnss.horizontalDilution": 3.3, "navigation.courseOverGroundMagnetic": 0.17802358374406965, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965315}
+	},
+	{
+		"time" : "2022-12-13 21:03:05.202",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.40989965,
+		"longitude" : 2.287289433333333,
+		"speedoverground" : 5.4,
+		"courseovergroundtrue" : 9.2,
+		"windspeedapparent" : 14.4,
+		"anglespeedapparent" : 26.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.16057029122014124, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.16057029122014124, "environment.depth.belowKeel": 6, "navigation.speedThroughWater": 2.7780007037601786, "environment.water.temperature": 280.25, "environment.depth.belowSurface": 6, "environment.wind.directionTrue": 1.1362093433077387, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.403333333333334, "propulsion.engine_2.revolutions": 11.261666666666667, "environment.depth.belowTransducer": 6, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.1362093433077387, "navigation.gnss.horizontalDilution": 3.8, "navigation.courseOverGroundMagnetic": 0.16057029122014124, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965375}
+	},
+	{
+		"time" : "2022-12-13 21:04:05.224",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.411323816666666,
+		"longitude" : 2.287555033333333,
+		"speedoverground" : 5.1,
+		"courseovergroundtrue" : 7.6,
+		"windspeedapparent" : 9.3,
+		"anglespeedapparent" : 22.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.1326450231818558, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.1326450231818558, "environment.depth.belowKeel": 5.4, "navigation.speedThroughWater": 2.6236673313290573, "environment.water.temperature": 279.95, "environment.depth.belowSurface": 5.4, "environment.wind.directionTrue": 0.9337511500301693, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.261666666666667, "propulsion.engine_2.revolutions": 10.825, "environment.depth.belowTransducer": 5.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.9337511500301693, "navigation.gnss.horizontalDilution": 3.3, "navigation.courseOverGroundMagnetic": 0.1326450231818558, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965435}
+	},
+	{
+		"time" : "2022-12-13 21:05:05.253",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.412672,
+		"longitude" : 2.2878124166666667,
+		"speedoverground" : 4.7,
+		"courseovergroundtrue" : 8.4,
+		"windspeedapparent" : 16.5,
+		"anglespeedapparent" : 24.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.14660765720099855, "environment.wind.speedTrue": 5.3, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.14660765720099855, "environment.depth.belowKeel": 4.5, "navigation.speedThroughWater": 2.417889501420896, "environment.water.temperature": 279.65, "environment.depth.belowSurface": 4.5, "environment.wind.directionTrue": 0.7696902003052424, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.261666666666667, "propulsion.engine_2.revolutions": 10.825, "environment.depth.belowTransducer": 4.5, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.7696902003052424, "navigation.gnss.horizontalDilution": 5, "navigation.courseOverGroundMagnetic": 0.14660765720099855, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965495}
+	},
+	{
+		"time" : "2022-12-13 21:06:05.281",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.413960216666666,
+		"longitude" : 2.288052583333333,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 7.6,
+		"windspeedapparent" : 19.1,
+		"anglespeedapparent" : 24.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.1326450231818558, "environment.wind.speedTrue": 7.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.1326450231818558, "environment.depth.belowKeel": 3.3, "navigation.speedThroughWater": 2.4693339588979364, "environment.water.temperature": 279.65, "environment.depth.belowSurface": 3.3, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.716666666666667, "propulsion.engine_2.revolutions": 11.716666666666667, "environment.depth.belowTransducer": 3.3, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 3.1, "navigation.courseOverGroundMagnetic": 0.1326450231818558, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965555}
+	},
+	{
+		"time" : "2022-12-13 21:07:05.315",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.41527805,
+		"longitude" : 2.288307083333333,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 7.6,
+		"windspeedapparent" : 22.1,
+		"anglespeedapparent" : 22.3,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.1326450231818558, "environment.wind.speedTrue": 5.3, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.1326450231818558, "environment.depth.belowKeel": 4, "navigation.speedThroughWater": 2.4693339588979364, "environment.water.temperature": 279.54999999999995, "environment.depth.belowSurface": 4, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.261666666666667, "propulsion.engine_2.revolutions": 12.681666666666667, "environment.depth.belowTransducer": 4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 2.7, "navigation.courseOverGroundMagnetic": 0.1326450231818558, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965615}
+	},
+	{
+		"time" : "2022-12-13 21:08:05.353",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.41658073333333,
+		"longitude" : 2.2885240166666665,
+		"speedoverground" : 4.7,
+		"courseovergroundtrue" : 6.9,
+		"windspeedapparent" : 16.6,
+		"anglespeedapparent" : 12.4,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.12042771841510595, "environment.wind.speedTrue": 1.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.12042771841510595, "environment.depth.belowKeel": 4.9, "navigation.speedThroughWater": 2.417889501420896, "environment.water.temperature": 279.45, "environment.depth.belowSurface": 4.9, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.716666666666667, "propulsion.engine_2.revolutions": 14.860000000000001, "environment.depth.belowTransducer": 4.9, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 3.1, "navigation.courseOverGroundMagnetic": 0.12042771841510595, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965675}
+	},
+	{
+		"time" : "2022-12-13 21:09:05.371",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.41785333333333,
+		"longitude" : 2.2887258333333333,
+		"speedoverground" : 4.5,
+		"courseovergroundtrue" : 6.2,
+		"windspeedapparent" : 8.6,
+		"anglespeedapparent" : 9.2,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.10821041364835607, "environment.wind.speedTrue": 1.2, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.10821041364835607, "environment.depth.belowKeel": 6, "navigation.speedThroughWater": 2.3150005864668155, "environment.water.temperature": 279.25, "environment.depth.belowSurface": 6, "environment.wind.directionTrue": 0.5742133240372442, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.403333333333334, "propulsion.engine_2.revolutions": 13.195, "environment.depth.belowTransducer": 6, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5742133240372442, "navigation.gnss.horizontalDilution": 2.7, "navigation.courseOverGroundMagnetic": 0.10821041364835607, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965735}
+	},
+	{
+		"time" : "2022-12-13 21:10:05.404",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.41911275,
+		"longitude" : 2.28890385,
+		"speedoverground" : 4.6,
+		"courseovergroundtrue" : 6.9,
+		"windspeedapparent" : 7.2,
+		"anglespeedapparent" : 7.8,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.12042771841510595, "environment.wind.speedTrue": 1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.12042771841510595, "environment.depth.belowKeel": 7.3, "navigation.speedThroughWater": 2.3664450439438554, "environment.water.temperature": 279.25, "environment.depth.belowSurface": 7.3, "environment.wind.directionTrue": 0.5742133240372442, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 12.681666666666667, "environment.depth.belowTransducer": 7.3, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5742133240372442, "navigation.gnss.horizontalDilution": 2.7, "navigation.courseOverGroundMagnetic": 0.12042771841510595, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965795}
+	},
+	{
+		"time" : "2022-12-13 21:11:05.414",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.42043938333333,
+		"longitude" : 2.2891021,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 6.9,
+		"windspeedapparent" : 7.5,
+		"anglespeedapparent" : 9.6,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.12042771841510595, "environment.wind.speedTrue": 1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.12042771841510595, "environment.depth.belowKeel": 7.3, "navigation.speedThroughWater": 2.4693339588979364, "environment.water.temperature": 279.54999999999995, "environment.depth.belowSurface": 7.3, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 12.681666666666667, "environment.depth.belowTransducer": 7.3, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 4.1, "navigation.courseOverGroundMagnetic": 0.12042771841510595, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965855}
+	},
+	{
+		"time" : "2022-12-13 21:12:05.470",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.42173171666666,
+		"longitude" : 2.2892923166666668,
+		"speedoverground" : 4.5,
+		"courseovergroundtrue" : 5.7,
+		"windspeedapparent" : 7.3,
+		"anglespeedapparent" : 14.8,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.09948376738639188, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.09948376738639188, "environment.depth.belowKeel": 7.3, "navigation.speedThroughWater": 2.3150005864668155, "environment.water.temperature": 279.54999999999995, "environment.depth.belowSurface": 7.3, "environment.wind.directionTrue": 0.7696902003052424, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 12.681666666666667, "environment.depth.belowTransducer": 7.3, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.7696902003052424, "navigation.gnss.horizontalDilution": 5, "navigation.courseOverGroundMagnetic": 0.09948376738639188, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965915}
+	},
+	{
+		"time" : "2022-12-13 21:13:05.493",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.42296415,
+		"longitude" : 2.28942895,
+		"speedoverground" : 4.4,
+		"courseovergroundtrue" : 4.2,
+		"windspeedapparent" : 6.9,
+		"anglespeedapparent" : 12.4,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.07330382860049928, "environment.wind.speedTrue": 1.2, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.07330382860049928, "environment.depth.belowKeel": 11.8, "navigation.speedThroughWater": 2.263556128989775, "environment.water.temperature": 279.84999999999997, "environment.depth.belowSurface": 11.8, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.2, "propulsion.engine_2.revolutions": 11.716666666666667, "environment.depth.belowTransducer": 11.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 4.1, "navigation.courseOverGroundMagnetic": 0.07330382860049928, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670965975}
+	},
+	{
+		"time" : "2022-12-13 21:14:05.507",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.42416923333333,
+		"longitude" : 2.2895500166666665,
+		"speedoverground" : 4.4,
+		"courseovergroundtrue" : 4.7,
+		"windspeedapparent" : 11.3,
+		"anglespeedapparent" : 13.3,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.08203047486246347, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.08203047486246347, "environment.depth.belowKeel": 13, "navigation.speedThroughWater": 2.263556128989775, "environment.water.temperature": 280.04999999999995, "environment.depth.belowSurface": 13, "environment.wind.directionTrue": 0.5201081172130663, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 11.261666666666667, "environment.depth.belowTransducer": 13, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5201081172130663, "navigation.gnss.horizontalDilution": 4.7, "navigation.courseOverGroundMagnetic": 0.08203047486246347, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966035}
+	},
+	{
+		"time" : "2022-12-13 21:15:05.532",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.42538771666667,
+		"longitude" : 2.2896824166666665,
+		"speedoverground" : 4.5,
+		"courseovergroundtrue" : 4.7,
+		"windspeedapparent" : 9.1,
+		"anglespeedapparent" : 18.6,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.08203047486246347, "environment.wind.speedTrue": 2.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.08203047486246347, "environment.depth.belowKeel": 14.4, "navigation.speedThroughWater": 2.3150005864668155, "environment.water.temperature": 279.84999999999997, "environment.depth.belowSurface": 14.4, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 12.19, "environment.depth.belowTransducer": 14.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 3.6, "navigation.courseOverGroundMagnetic": 0.08203047486246347, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966095}
+	},
+	{
+		"time" : "2022-12-13 21:16:05.578",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.42659741666667,
+		"longitude" : 2.2898227,
+		"speedoverground" : 4.4,
+		"courseovergroundtrue" : 4.7,
+		"windspeedapparent" : 11.2,
+		"anglespeedapparent" : 19.6,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.08203047486246347, "environment.wind.speedTrue": 3.7, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.08203047486246347, "environment.depth.belowKeel": 13, "navigation.speedThroughWater": 2.263556128989775, "environment.water.temperature": 279.45, "environment.depth.belowSurface": 13, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 12.681666666666667, "environment.depth.belowTransducer": 13, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 5, "navigation.courseOverGroundMagnetic": 0.08203047486246347, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966155}
+	},
+	{
+		"time" : "2022-12-13 21:17:05.597",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.42780106666667,
+		"longitude" : 2.2899329666666666,
+		"speedoverground" : 4.3,
+		"courseovergroundtrue" : 4.2,
+		"windspeedapparent" : 12.5,
+		"anglespeedapparent" : 15.5,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.07330382860049928, "environment.wind.speedTrue": 1.2, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.07330382860049928, "environment.depth.belowKeel": 14.4, "navigation.speedThroughWater": 2.2121116715127345, "environment.water.temperature": 279.95, "environment.depth.belowSurface": 14.4, "environment.wind.directionTrue": 0.8482300166629202, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 12.19, "environment.depth.belowTransducer": 14.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.8482300166629202, "navigation.gnss.horizontalDilution": 2.7, "navigation.courseOverGroundMagnetic": 0.07330382860049928, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966215}
+	},
+	{
+		"time" : "2022-12-13 21:18:05.608",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.42899953333333,
+		"longitude" : 2.2900571666666667,
+		"speedoverground" : 4.3,
+		"courseovergroundtrue" : 4.2,
+		"windspeedapparent" : 9.2,
+		"anglespeedapparent" : 32.1,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.07330382860049928, "environment.wind.speedTrue": 3.1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.07330382860049928, "environment.depth.belowKeel": 15.8, "navigation.speedThroughWater": 2.2121116715127345, "environment.water.temperature": 279.84999999999997, "environment.depth.belowSurface": 15.8, "environment.wind.directionTrue": 1.0297442589117756, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 11.716666666666667, "environment.depth.belowTransducer": 15.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.0297442589117756, "navigation.gnss.horizontalDilution": 3.1, "navigation.courseOverGroundMagnetic": 0.07330382860049928, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966275}
+	},
+	{
+		"time" : "2022-12-13 21:19:05.630",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.43017308333334,
+		"longitude" : 2.290175666666667,
+		"speedoverground" : 4.2,
+		"courseovergroundtrue" : 4.7,
+		"windspeedapparent" : 12.2,
+		"anglespeedapparent" : 26.6,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.08203047486246347, "environment.wind.speedTrue": 4.4, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.08203047486246347, "environment.depth.belowKeel": 11.8, "navigation.speedThroughWater": 2.1606672140356946, "environment.water.temperature": 279.95, "environment.depth.belowSurface": 11.8, "environment.wind.directionTrue": 0.7696902003052424, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 13.728333333333333, "environment.depth.belowTransducer": 11.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.7696902003052424, "navigation.gnss.horizontalDilution": 3.6, "navigation.courseOverGroundMagnetic": 0.08203047486246347, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966335}
+	},
+	{
+		"time" : "2022-12-13 21:20:05.651",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.431364,
+		"longitude" : 2.2902968333333336,
+		"speedoverground" : 4.2,
+		"courseovergroundtrue" : 4.7,
+		"windspeedapparent" : 9.9,
+		"anglespeedapparent" : 14.2,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.08203047486246347, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.08203047486246347, "environment.depth.belowKeel": 9.7, "navigation.speedThroughWater": 2.1606672140356946, "environment.water.temperature": 279.95, "environment.depth.belowSurface": 9.7, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 13.195, "environment.depth.belowTransducer": 9.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 3.6, "navigation.courseOverGroundMagnetic": 0.08203047486246347, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966395}
+	},
+	{
+		"time" : "2022-12-13 21:21:05.683",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.43257,
+		"longitude" : 2.2904335666666666,
+		"speedoverground" : 4.4,
+		"courseovergroundtrue" : 4.7,
+		"windspeedapparent" : 8.1,
+		"anglespeedapparent" : 19.1,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.08203047486246347, "environment.wind.speedTrue": 2.1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.08203047486246347, "environment.depth.belowKeel": 11.8, "navigation.speedThroughWater": 2.263556128989775, "environment.water.temperature": 279.65, "environment.depth.belowSurface": 11.8, "environment.wind.directionTrue": 0.7696902003052424, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.486666666666668, "propulsion.engine_2.revolutions": 12.681666666666667, "environment.depth.belowTransducer": 11.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.7696902003052424, "navigation.gnss.horizontalDilution": 2.4, "navigation.courseOverGroundMagnetic": 0.08203047486246347, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966455}
+	},
+	{
+		"time" : "2022-12-13 21:22:05.702",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.4338153,
+		"longitude" : 2.2905634333333333,
+		"speedoverground" : 4.4,
+		"courseovergroundtrue" : 4.2,
+		"windspeedapparent" : 7.6,
+		"anglespeedapparent" : 10.9,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.07330382860049928, "environment.wind.speedTrue": 1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.07330382860049928, "environment.depth.belowKeel": 13, "navigation.speedThroughWater": 2.263556128989775, "environment.water.temperature": 279.45, "environment.depth.belowSurface": 13, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 13.195, "environment.depth.belowTransducer": 13, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 1.8, "navigation.courseOverGroundMagnetic": 0.07330382860049928, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966515}
+	},
+	{
+		"time" : "2022-12-13 21:23:05.714",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.43504795,
+		"longitude" : 2.2906984,
+		"speedoverground" : 4.5,
+		"courseovergroundtrue" : 4.7,
+		"windspeedapparent" : 8.0,
+		"anglespeedapparent" : 21.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.08203047486246347, "environment.wind.speedTrue": 2.1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.08203047486246347, "environment.depth.belowKeel": 13, "navigation.speedThroughWater": 2.3150005864668155, "environment.water.temperature": 279.65, "environment.depth.belowSurface": 13, "environment.wind.directionTrue": 0.8482300166629202, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.2, "propulsion.engine_2.revolutions": 13.728333333333333, "environment.depth.belowTransducer": 13, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.8482300166629202, "navigation.gnss.horizontalDilution": 1.6, "navigation.courseOverGroundMagnetic": 0.08203047486246347, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966575}
+	},
+	{
+		"time" : "2022-12-13 21:24:05.728",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.436295183333336,
+		"longitude" : 2.2908305666666666,
+		"speedoverground" : 4.5,
+		"courseovergroundtrue" : 4.2,
+		"windspeedapparent" : 7.9,
+		"anglespeedapparent" : 20.9,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.07330382860049928, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.07330382860049928, "environment.depth.belowKeel": 11.8, "navigation.speedThroughWater": 2.3150005864668155, "environment.water.temperature": 279.54999999999995, "environment.depth.belowSurface": 11.8, "environment.wind.directionTrue": 1.0297442589117756, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.2, "propulsion.engine_2.revolutions": 14.281666666666666, "environment.depth.belowTransducer": 11.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 1.0297442589117756, "navigation.gnss.horizontalDilution": 1.4, "navigation.courseOverGroundMagnetic": 0.07330382860049928, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966635}
+	},
+	{
+		"time" : "2022-12-13 21:25:05.748",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.437534766666666,
+		"longitude" : 2.2909366166666665,
+		"speedoverground" : 4.5,
+		"courseovergroundtrue" : 3.1,
+		"windspeedapparent" : 7.9,
+		"anglespeedapparent" : 14.2,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.054105206824178034, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.054105206824178034, "environment.depth.belowKeel": 11.8, "navigation.speedThroughWater": 2.3150005864668155, "environment.water.temperature": 279.84999999999997, "environment.depth.belowSurface": 11.8, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10, "propulsion.engine_2.revolutions": 13.195, "environment.depth.belowTransducer": 11.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 0.9, "navigation.courseOverGroundMagnetic": 0.054105206824178034, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966695}
+	},
+	{
+		"time" : "2022-12-13 21:26:05.787",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.43881773333333,
+		"longitude" : 2.2910521833333335,
+		"speedoverground" : 4.6,
+		"courseovergroundtrue" : 4.2,
+		"windspeedapparent" : 8.5,
+		"anglespeedapparent" : 11.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.07330382860049928, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.07330382860049928, "environment.depth.belowKeel": 17.5, "navigation.speedThroughWater": 2.3664450439438554, "environment.water.temperature": 279.45, "environment.depth.belowSurface": 17.5, "environment.wind.directionTrue": 0.5742133240372442, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.825, "propulsion.engine_2.revolutions": 13.728333333333333, "environment.depth.belowTransducer": 17.5, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5742133240372442, "navigation.gnss.horizontalDilution": 1.4, "navigation.courseOverGroundMagnetic": 0.07330382860049928, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966755}
+	},
+	{
+		"time" : "2022-12-13 21:27:05.827",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.4401189,
+		"longitude" : 2.2911686833333333,
+		"speedoverground" : 4.7,
+		"courseovergroundtrue" : 4.2,
+		"windspeedapparent" : 7.0,
+		"anglespeedapparent" : 7.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.07330382860049928, "environment.wind.speedTrue": 1.2, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.07330382860049928, "environment.depth.belowKeel": 23.4, "navigation.speedThroughWater": 2.417889501420896, "environment.water.temperature": 279.54999999999995, "environment.depth.belowSurface": 23.4, "environment.wind.directionTrue": 0.47123889814606673, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10, "propulsion.engine_2.revolutions": 14.281666666666666, "environment.depth.belowTransducer": 23.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.47123889814606673, "navigation.gnss.horizontalDilution": 1.2, "navigation.courseOverGroundMagnetic": 0.07330382860049928, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966815}
+	},
+	{
+		"time" : "2022-12-13 21:28:05.867",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.441560683333336,
+		"longitude" : 2.291303533333333,
+		"speedoverground" : 4.9,
+		"courseovergroundtrue" : 4.2,
+		"windspeedapparent" : 7.5,
+		"anglespeedapparent" : 11.8,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.07330382860049928, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.07330382860049928, "environment.depth.belowKeel": 28.4, "navigation.speedThroughWater": 2.5207784163749767, "environment.water.temperature": 279.45, "environment.depth.belowSurface": 28.4, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.403333333333334, "propulsion.engine_2.revolutions": 16.085, "environment.depth.belowTransducer": 28.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 1.1, "navigation.courseOverGroundMagnetic": 0.07330382860049928, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966875}
+	},
+	{
+		"time" : "2022-12-13 21:29:05.889",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.44287495,
+		"longitude" : 2.291422783333333,
+		"speedoverground" : 4.7,
+		"courseovergroundtrue" : 3.8,
+		"windspeedapparent" : 10.4,
+		"anglespeedapparent" : 12.2,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.0663225115909279, "environment.wind.speedTrue": 1.5, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.0663225115909279, "environment.depth.belowKeel": 28.4, "navigation.speedThroughWater": 2.417889501420896, "environment.water.temperature": 279.54999999999995, "environment.depth.belowSurface": 28.4, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.825, "propulsion.engine_2.revolutions": 18.113333333333333, "environment.depth.belowTransducer": 28.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 1.2, "navigation.courseOverGroundMagnetic": 0.0663225115909279, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966935}
+	},
+	{
+		"time" : "2022-12-13 21:30:05.922",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.44416415,
+		"longitude" : 2.2915161166666667,
+		"speedoverground" : 4.7,
+		"courseovergroundtrue" : 2.9,
+		"windspeedapparent" : 10.1,
+		"anglespeedapparent" : 20.9,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.050614548319392355, "environment.wind.speedTrue": 3.1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.050614548319392355, "environment.depth.belowKeel": 23.4, "navigation.speedThroughWater": 2.417889501420896, "environment.water.temperature": 279.45, "environment.depth.belowSurface": 23.4, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.825, "propulsion.engine_2.revolutions": 15.46, "environment.depth.belowTransducer": 23.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 1.4, "navigation.courseOverGroundMagnetic": 0.050614548319392355, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670966995}
+	},
+	{
+		"time" : "2022-12-13 21:31:05.937",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.44544285,
+		"longitude" : 2.2916172833333333,
+		"speedoverground" : 4.6,
+		"courseovergroundtrue" : 3.5,
+		"windspeedapparent" : 25.5,
+		"anglespeedapparent" : 23.5,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.06108652383374939, "environment.wind.speedTrue": 9.2, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.06108652383374939, "environment.depth.belowKeel": 19.3, "navigation.speedThroughWater": 2.3664450439438554, "environment.water.temperature": 279.25, "environment.depth.belowSurface": 19.3, "environment.wind.directionTrue": 0.5742133240372442, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.825, "propulsion.engine_2.revolutions": 16.085, "environment.depth.belowTransducer": 19.3, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5742133240372442, "navigation.gnss.horizontalDilution": 1.6, "navigation.courseOverGroundMagnetic": 0.06108652383374939, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967055}
+	},
+	{
+		"time" : "2022-12-13 21:32:05.953",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.44671025,
+		"longitude" : 2.2917142166666666,
+		"speedoverground" : 4.6,
+		"courseovergroundtrue" : 3.1,
+		"windspeedapparent" : 22.0,
+		"anglespeedapparent" : 17.4,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.054105206824178034, "environment.wind.speedTrue": 4.4, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.054105206824178034, "environment.depth.belowKeel": 21.2, "navigation.speedThroughWater": 2.3664450439438554, "environment.water.temperature": 279.54999999999995, "environment.depth.belowSurface": 21.2, "environment.wind.directionTrue": 0.5201081172130663, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.825, "propulsion.engine_2.revolutions": 16.735, "environment.depth.belowTransducer": 21.2, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5201081172130663, "navigation.gnss.horizontalDilution": 1.4, "navigation.courseOverGroundMagnetic": 0.054105206824178034, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967114}
+	},
+	{
+		"time" : "2022-12-13 21:33:05.972",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.447963533333336,
+		"longitude" : 2.2918140833333336,
+		"speedoverground" : 4.4,
+		"courseovergroundtrue" : 3.5,
+		"windspeedapparent" : 22.0,
+		"anglespeedapparent" : 21.8,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.06108652383374939, "environment.wind.speedTrue": 6.4, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.06108652383374939, "environment.depth.belowKeel": 23.4, "navigation.speedThroughWater": 2.263556128989775, "environment.water.temperature": 279.25, "environment.depth.belowSurface": 23.4, "environment.wind.directionTrue": 0.5742133240372442, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.825, "propulsion.engine_2.revolutions": 16.085, "environment.depth.belowTransducer": 23.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5742133240372442, "navigation.gnss.horizontalDilution": 1.6, "navigation.courseOverGroundMagnetic": 0.06108652383374939, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967175}
+	},
+	{
+		"time" : "2022-12-13 21:34:05.994",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.44916808333333,
+		"longitude" : 2.2919039666666667,
+		"speedoverground" : 4.3,
+		"courseovergroundtrue" : 3.1,
+		"windspeedapparent" : 21.7,
+		"anglespeedapparent" : 24.7,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.054105206824178034, "environment.wind.speedTrue": 6.4, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.054105206824178034, "environment.depth.belowKeel": 23.4, "navigation.speedThroughWater": 2.2121116715127345, "environment.water.temperature": 279.04999999999995, "environment.depth.belowSurface": 23.4, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.261666666666667, "propulsion.engine_2.revolutions": 18.845000000000002, "environment.depth.belowTransducer": 23.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 1.6, "navigation.courseOverGroundMagnetic": 0.054105206824178034, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967235}
+	},
+	{
+		"time" : "2022-12-13 21:35:06.024",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.45040101666667,
+		"longitude" : 2.2919925833333332,
+		"speedoverground" : 4.5,
+		"courseovergroundtrue" : 3.5,
+		"windspeedapparent" : 14.3,
+		"anglespeedapparent" : 24.1,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.06108652383374939, "environment.wind.speedTrue": 4.4, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.06108652383374939, "environment.depth.belowKeel": 21.2, "navigation.speedThroughWater": 2.3150005864668155, "environment.water.temperature": 278.95, "environment.depth.belowSurface": 21.2, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10, "propulsion.engine_2.revolutions": 20.398333333333333, "environment.depth.belowTransducer": 21.2, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 1.8, "navigation.courseOverGroundMagnetic": 0.06108652383374939, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967295}
+	},
+	{
+		"time" : "2022-12-13 21:36:06.057",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.451662666666664,
+		"longitude" : 2.2920915833333333,
+		"speedoverground" : 4.6,
+		"courseovergroundtrue" : 3.1,
+		"windspeedapparent" : 29.1,
+		"anglespeedapparent" : 39.0,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.054105206824178034, "environment.wind.speedTrue": 13.2, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.054105206824178034, "environment.depth.belowKeel": 19.3, "navigation.speedThroughWater": 2.3664450439438554, "environment.water.temperature": 279.04999999999995, "environment.depth.belowSurface": 19.3, "environment.wind.directionTrue": 0.8482300166629202, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 19.60666666666667, "environment.depth.belowTransducer": 19.3, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.8482300166629202, "navigation.gnss.horizontalDilution": 1.8, "navigation.courseOverGroundMagnetic": 0.054105206824178034, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967355}
+	},
+	{
+		"time" : "2022-12-13 21:37:06.080",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.45293165,
+		"longitude" : 2.2921954833333333,
+		"speedoverground" : 4.7,
+		"courseovergroundtrue" : 3.8,
+		"windspeedapparent" : 44.2,
+		"anglespeedapparent" : 26.1,
+		"status" : "sailing",
+		"metrics" : {"navigation.headingTrue": 0.0663225115909279, "environment.wind.speedTrue": 20.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.0663225115909279, "environment.depth.belowKeel": 17.5, "navigation.speedThroughWater": 2.417889501420896, "environment.water.temperature": 279.45, "environment.depth.belowSurface": 17.5, "environment.wind.directionTrue": 0.5742133240372442, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 22.08, "environment.depth.belowTransducer": 17.5, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5742133240372442, "navigation.gnss.horizontalDilution": 2.1, "navigation.courseOverGroundMagnetic": 0.0663225115909279, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967415}
+	},
+	{
+		"time" : "2022-12-13 21:38:06.100",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.45424523333333,
+		"longitude" : 2.2922960833333335,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 3.1,
+		"windspeedapparent" : 37.6,
+		"anglespeedapparent" : 14.2,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.054105206824178034, "environment.wind.speedTrue": 4.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.054105206824178034, "environment.depth.belowKeel": 15.8, "navigation.speedThroughWater": 2.4693339588979364, "environment.water.temperature": 279.45, "environment.depth.belowSurface": 15.8, "environment.wind.directionTrue": 0.42760566683624573, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 23.9, "environment.depth.belowTransducer": 15.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.42760566683624573, "navigation.gnss.horizontalDilution": 1.6, "navigation.courseOverGroundMagnetic": 0.054105206824178034, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967475}
+	},
+	{
+		"time" : "2022-12-13 21:39:06.118",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.4555779,
+		"longitude" : 2.292398116666667,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 3.5,
+		"windspeedapparent" : 15.7,
+		"anglespeedapparent" : 10.8,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.06108652383374939, "environment.wind.speedTrue": 3.3, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.06108652383374939, "environment.depth.belowKeel": 15.8, "navigation.speedThroughWater": 2.4693339588979364, "environment.water.temperature": 279.45, "environment.depth.belowSurface": 15.8, "environment.wind.directionTrue": 0.38746309403121043, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.2, "propulsion.engine_2.revolutions": 22.08, "environment.depth.belowTransducer": 15.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.38746309403121043, "navigation.gnss.horizontalDilution": 1.4, "navigation.courseOverGroundMagnetic": 0.06108652383374939, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967535}
+	},
+	{
+		"time" : "2022-12-13 21:40:06.142",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.45691458333334,
+		"longitude" : 2.2925072833333333,
+		"speedoverground" : 4.9,
+		"courseovergroundtrue" : 3.1,
+		"windspeedapparent" : 15.7,
+		"anglespeedapparent" : 15.7,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.054105206824178034, "environment.wind.speedTrue": 4.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.054105206824178034, "environment.depth.belowKeel": 15.8, "navigation.speedThroughWater": 2.5207784163749767, "environment.water.temperature": 279.65, "environment.depth.belowSurface": 15.8, "environment.wind.directionTrue": 0.47123889814606673, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 25.87, "environment.depth.belowTransducer": 15.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.47123889814606673, "navigation.gnss.horizontalDilution": 0.8, "navigation.courseOverGroundMagnetic": 0.054105206824178034, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967595}
+	},
+	{
+		"time" : "2022-12-13 21:41:06.155",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.458240233333335,
+		"longitude" : 2.2926219333333333,
+		"speedoverground" : 4.7,
+		"courseovergroundtrue" : 3.8,
+		"windspeedapparent" : 12.4,
+		"anglespeedapparent" : 9.2,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.0663225115909279, "environment.wind.speedTrue": 1.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.0663225115909279, "environment.depth.belowKeel": 14.4, "navigation.speedThroughWater": 2.417889501420896, "environment.water.temperature": 279.95, "environment.depth.belowSurface": 14.4, "environment.wind.directionTrue": 0.47123889814606673, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 10.611666666666668, "propulsion.engine_2.revolutions": 26.916666666666668, "environment.depth.belowTransducer": 14.4, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.47123889814606673, "navigation.gnss.horizontalDilution": 0.8, "navigation.courseOverGroundMagnetic": 0.0663225115909279, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967655}
+	},
+	{
+		"time" : "2022-12-13 21:42:06.187",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.45955073333333,
+		"longitude" : 2.2927578,
+		"speedoverground" : 4.8,
+		"courseovergroundtrue" : 4.7,
+		"windspeedapparent" : 9.8,
+		"anglespeedapparent" : 12.4,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.08203047486246347, "environment.wind.speedTrue": 1.6, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.08203047486246347, "environment.depth.belowKeel": 13, "navigation.speedThroughWater": 2.4693339588979364, "environment.water.temperature": 279.84999999999997, "environment.depth.belowSurface": 13, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 25.87, "environment.depth.belowTransducer": 13, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 0.6, "navigation.courseOverGroundMagnetic": 0.08203047486246347, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967715}
+	},
+	{
+		"time" : "2022-12-13 21:43:06.208",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.46092023333333,
+		"longitude" : 2.2929017833333334,
+		"speedoverground" : 5.0,
+		"courseovergroundtrue" : 4.2,
+		"windspeedapparent" : 8.2,
+		"anglespeedapparent" : 11.7,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.07330382860049928, "environment.wind.speedTrue": 1.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.07330382860049928, "environment.depth.belowKeel": 13, "navigation.speedThroughWater": 2.572222873852017, "environment.water.temperature": 279.84999999999997, "environment.depth.belowSurface": 13, "environment.wind.directionTrue": 0.5742133240372442, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 28.003333333333334, "environment.depth.belowTransducer": 13, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5742133240372442, "navigation.gnss.horizontalDilution": 0.5, "navigation.courseOverGroundMagnetic": 0.07330382860049928, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967775}
+	},
+	{
+		"time" : "2022-12-13 21:44:06.237",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.46235585,
+		"longitude" : 2.2930669666666668,
+		"speedoverground" : 5.3,
+		"courseovergroundtrue" : 5.1,
+		"windspeedapparent" : 10.6,
+		"anglespeedapparent" : 13.7,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.08901179187203483, "environment.wind.speedTrue": 1.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.08901179187203483, "environment.depth.belowKeel": 11.8, "navigation.speedThroughWater": 2.726556246283138, "environment.water.temperature": 279.65, "environment.depth.belowSurface": 11.8, "environment.wind.directionTrue": 0.698131700957136, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 25.87, "environment.depth.belowTransducer": 11.8, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.698131700957136, "navigation.gnss.horizontalDilution": 0.6, "navigation.courseOverGroundMagnetic": 0.08901179187203483, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967835}
+	},
+	{
+		"time" : "2022-12-13 21:45:06.284",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.46385398333334,
+		"longitude" : 2.2932485833333334,
+		"speedoverground" : 5.4,
+		"courseovergroundtrue" : 5.7,
+		"windspeedapparent" : 7.9,
+		"anglespeedapparent" : 7.3,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.09948376738639188, "environment.wind.speedTrue": 1, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.09948376738639188, "environment.depth.belowKeel": 9.7, "navigation.speedThroughWater": 2.7780007037601786, "environment.water.temperature": 280.04999999999995, "environment.depth.belowSurface": 9.7, "environment.wind.directionTrue": 0.5742133240372442, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 11.04, "propulsion.engine_2.revolutions": 23.9, "environment.depth.belowTransducer": 9.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.5742133240372442, "navigation.gnss.horizontalDilution": 0.5, "navigation.courseOverGroundMagnetic": 0.09948376738639188, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967895}
+	},
+	{
+		"time" : "2022-12-13 21:46:06.327",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.46533328333334,
+		"longitude" : 2.2934791,
+		"speedoverground" : 5.5,
+		"courseovergroundtrue" : 6.9,
+		"windspeedapparent" : 9.3,
+		"anglespeedapparent" : 11.3,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.12042771841510595, "environment.wind.speedTrue": 1.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.12042771841510595, "environment.depth.belowKeel": 9.7, "navigation.speedThroughWater": 2.829445161237219, "environment.water.temperature": 280.25, "environment.depth.belowSurface": 9.7, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 12.433333333333334, "propulsion.engine_2.revolutions": 22.971666666666668, "environment.depth.belowTransducer": 9.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 0.6, "navigation.courseOverGroundMagnetic": 0.12042771841510595, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967955}
+	},
+	{
+		"time" : "2022-12-13 21:47:06.327",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.46533328333334,
+		"longitude" : 2.2934791,
+		"speedoverground" : 5.5,
+		"courseovergroundtrue" : 6.9,
+		"windspeedapparent" : 9.3,
+		"anglespeedapparent" : 11.3,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.12042771841510595, "environment.wind.speedTrue": 1.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.12042771841510595, "environment.depth.belowKeel": 9.7, "navigation.speedThroughWater": 2.829445161237219, "environment.water.temperature": 280.25, "environment.depth.belowSurface": 9.7, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 12.433333333333334, "propulsion.engine_2.revolutions": 22.971666666666668, "environment.depth.belowTransducer": 9.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 0.6, "navigation.courseOverGroundMagnetic": 0.12042771841510595, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967955}
+	},
+	{
+		"time" : "2022-12-13 21:48:06.327",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.46533328333334,
+		"longitude" : 2.2934791,
+		"speedoverground" : 5.5,
+		"courseovergroundtrue" : 6.9,
+		"windspeedapparent" : 9.3,
+		"anglespeedapparent" : 11.3,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.12042771841510595, "environment.wind.speedTrue": 1.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.12042771841510595, "environment.depth.belowKeel": 9.7, "navigation.speedThroughWater": 2.829445161237219, "environment.water.temperature": 280.25, "environment.depth.belowSurface": 9.7, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 12.433333333333334, "propulsion.engine_2.revolutions": 22.971666666666668, "environment.depth.belowTransducer": 9.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 0.6, "navigation.courseOverGroundMagnetic": 0.12042771841510595, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967955}
+	},
+	{
+		"time" : "2022-12-13 21:49:06.327",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.46533328333334,
+		"longitude" : 2.2934791,
+		"speedoverground" : 5.5,
+		"courseovergroundtrue" : 6.9,
+		"windspeedapparent" : 9.3,
+		"anglespeedapparent" : 11.3,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.12042771841510595, "environment.wind.speedTrue": 1.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.12042771841510595, "environment.depth.belowKeel": 9.7, "navigation.speedThroughWater": 2.829445161237219, "environment.water.temperature": 280.25, "environment.depth.belowSurface": 9.7, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 12.433333333333334, "propulsion.engine_2.revolutions": 22.971666666666668, "environment.depth.belowTransducer": 9.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 0.6, "navigation.courseOverGroundMagnetic": 0.12042771841510595, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967955}
+	},
+	{
+		"time" : "2022-12-13 21:50:06.327",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.46533328333334,
+		"longitude" : 2.2934791,
+		"speedoverground" : 5.5,
+		"courseovergroundtrue" : 6.9,
+		"windspeedapparent" : 9.3,
+		"anglespeedapparent" : 11.3,
+		"status" : "motoring",
+		"metrics" : {"navigation.headingTrue": 0.12042771841510595, "environment.wind.speedTrue": 1.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.12042771841510595, "environment.depth.belowKeel": 9.7, "navigation.speedThroughWater": 2.829445161237219, "environment.water.temperature": 280.25, "environment.depth.belowSurface": 9.7, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 12.433333333333334, "propulsion.engine_2.revolutions": 22.971666666666668, "environment.depth.belowTransducer": 9.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 0.6, "navigation.courseOverGroundMagnetic": 0.12042771841510595, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967955}
+	},
+	{
+		"time" : "2022-12-13 21:51:06.327",
+		"client_id" : "vessels.urn:mrn:imo:mmsi:787654321",
+		"latitude" : 41.46533328333334,
+		"longitude" : 2.2934791,
+		"speedoverground" : 5.5,
+		"courseovergroundtrue" : 6.9,
+		"windspeedapparent" : 9.3,
+		"anglespeedapparent" : 11.3,
+		"status" : "moored",
+		"metrics" : {"navigation.headingTrue": 0.12042771841510595, "environment.wind.speedTrue": 1.8, "navigation.gnss.satellites": 4, "navigation.headingMagnetic": 0.12042771841510595, "environment.depth.belowKeel": 9.7, "navigation.speedThroughWater": 2.829445161237219, "environment.water.temperature": 280.25, "environment.depth.belowSurface": 9.7, "environment.wind.directionTrue": 0.6318091893662081, "navigation.gnss.antennaAltitude": 2, "navigation.gnss.differentialAge": 0, "propulsion.engine_1.revolutions": 12.433333333333334, "propulsion.engine_2.revolutions": 22.971666666666668, "environment.depth.belowTransducer": 9.7, "navigation.gnss.geoidalSeparation": 0, "environment.wind.directionMagnetic": 0.6318091893662081, "navigation.gnss.horizontalDilution": 0.6, "navigation.courseOverGroundMagnetic": 0.12042771841510595, "environment.depth.surfaceToTransducer": 0.3, "navigation.gnss.differentialReference": 0, "navigation.magneticVariationAgeOfService": 1670967955}
+	}
+]}

tests/package.json

@@ -0,0 +1,12 @@
+{
+  "scripts": {
+    "tests": "mocha index.js"
+  },
+  "dependencies": {
+    "mocha": "^10.2.0",
+    "mochawesome": "^7.1.3",
+    "moment": "^2.29.4",
+    "should": "^13.2.3",
+    "supertest": "^6.3.3"
+  }
+}

tests/sql/anonymous.sql

@@ -0,0 +1,20 @@
+---------------------------------------------------------------------------
+-- Listing
+--
+
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+-- output display format
+\x on
+
+\echo 'Validate anonymous access'
+SELECT api.ispublic_fn('kapla', 'public_test');
+SELECT api.ispublic_fn('kapla', 'public_logs_list');
+SELECT api.ispublic_fn('kapla', 'public_logs', 1);
+SELECT api.ispublic_fn('kapla', 'public_logs', 3);
+SELECT api.ispublic_fn('kapla', 'public_monitoring');
+SELECT api.ispublic_fn('kapla', 'public_timelapse');

tests/sql/anonymous.sql.output

@@ -0,0 +1,26 @@
+ current_database 
+------------------
+ signalk
+(1 row)
+
+You are now connected to database "signalk" as user "username".
+Expanded display is on.
+Validate anonymous access
+-[ RECORD 1 ]--
+ispublic_fn | f
+
+-[ RECORD 1 ]--
+ispublic_fn | f
+
+-[ RECORD 1 ]--
+ispublic_fn | t
+
+-[ RECORD 1 ]--
+ispublic_fn | f
+
+-[ RECORD 1 ]--
+ispublic_fn | t
+
+-[ RECORD 1 ]--
+ispublic_fn | f
+

tests/sql/badges.sql

@@ -0,0 +1,85 @@
+---------------------------------------------------------------------------
+-- Listing
+--
+
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+-- output display format
+\x on
+
+SELECT v.vessel_id as "vessel_id" FROM auth.vessels v WHERE v.owner_email = 'demo+kapla@openplotter.cloud' \gset
+--\echo :"vessel_id"
+SELECT set_config('vessel.id', :'vessel_id', false) IS NOT NULL as vessel_id;
+
+\echo 'Insert new api.logbook for badges'
+INSERT INTO api.logbook
+    (id, active, "name", "_from", "_from_lat", "_from_lng", "_to", "_to_lat", "_to_lng", track_geom, track_geog, track_geojson, "_from_time", "_to_time", distance, duration, avg_speed, max_speed, max_wind_speed, notes, vessel_id)
+    OVERRIDING SYSTEM VALUE VALUES
+    (nextval('api.logbook_id_seq'), false, 'Tropics Zone', NULL, NULL, NULL, NULL, NULL, NULL, 'SRID=4326;LINESTRING (-63.151124640791096 14.01074681627324, -77.0912026418618 12.870995731013664)'::public.geometry, NULL, NULL, NOW(), NOW(), 123, NULL, NULL, NULL, NULL, NULL, current_setting('vessel.id', false)),
+    (nextval('api.logbook_id_seq'), false, 'Alaska Zone', NULL, NULL, NULL, NULL, NULL, NULL, 'SRID=4326;LINESTRING (-143.5773697471158 59.4404631255976, -152.35402122385003 56.58243132943173)'::public.geometry, NULL, NULL, NOW(), NOW(), 1234, NULL, NULL, NULL, NULL, NULL, current_setting('vessel.id', false));
+
+\echo 'Set config'
+SELECT set_config('user.email', 'demo+kapla@openplotter.cloud', false);
+--SELECT set_config('vessel.client_id', 'vessels.urn:mrn:imo:mmsi:123456789', false);
+
+\echo 'Process badge'
+SELECT badges_logbook_fn(5,NOW()::TEXT);
+SELECT badges_logbook_fn(6,NOW()::TEXT);
+SELECT badges_geom_fn(5,NOW()::TEXT);
+SELECT badges_geom_fn(6,NOW()::TEXT);
+
+\echo 'Check badges for user'
+SELECT jsonb_object_keys ( a.preferences->'badges' ) FROM auth.accounts a;
+
+\echo 'Check details from vessel_id kapla'
+--SELECT get_user_settings_from_vesselid_fn('vessels.urn:mrn:imo:mmsi:123456789'::TEXT);
+SELECT 
+    json_build_object( 
+            'boat', v.name,
+            'recipient', a.first,
+            'email', v.owner_email,
+            --'settings', a.preferences,
+            'pushover_key', a.preferences->'pushover_key'
+            --'badges', a.preferences->'badges'
+            ) as user_settings
+    FROM auth.accounts a, auth.vessels v, api.metadata m
+    WHERE m.vessel_id = v.vessel_id
+        AND m.vessel_id = current_setting('vessel.id', false)
+        AND lower(a.email) = current_setting('user.email', false);
+
+\echo 'Insert new api.moorages for badges'
+INSERT INTO api.moorages
+    (id,"name",country,stay_code,stay_duration,reference_count,latitude,longitude,geog,home_flag,notes,vessel_id)
+    OVERRIDING SYSTEM VALUE VALUES
+    (8,'Badge Mooring Pro',NULL,3,'11 days 00:39:56.418',1,NULL,NULL,NULL,false,'Badge Mooring Pro',current_setting('vessel.id', false)),
+    (9,'Badge Anchormaster',NULL,2,'26 days 00:49:56.418',1,NULL,NULL,NULL,false,'Badge Anchormaster',current_setting('vessel.id', false));
+
+\echo 'Set config'
+SELECT set_config('user.email', 'demo+aava@openplotter.cloud', false);
+--SELECT set_config('vessel.client_id', 'vessels.urn:mrn:imo:mmsi:787654321', false);
+SELECT v.vessel_id as "vessel_id" FROM auth.vessels v WHERE v.owner_email = 'demo+aava@openplotter.cloud' \gset
+--\echo :"vessel_id"
+SELECT set_config('vessel.id', :'vessel_id', false) IS NOT NULL as vessel_id;
+
+\echo 'Process badge'
+SELECT badges_moorages_fn();
+
+\echo 'Check details from vessel_id aava'
+--SELECT get_user_settings_from_vesselid_fn('vessels.urn:mrn:imo:mmsi:787654321'::TEXT);
+SELECT 
+    json_build_object( 
+            'boat', v.name,
+            'recipient', a.first,
+            'email', v.owner_email,
+            --'settings', a.preferences,
+            'pushover_key', a.preferences->'pushover_key'
+            --'badges', a.preferences->'badges'
+            ) as user_settings
+    FROM auth.accounts a, auth.vessels v, api.metadata m
+    WHERE m.vessel_id = v.vessel_id
+        AND m.vessel_id = current_setting('vessel.id', false)
+        AND lower(a.email) = current_setting('user.email', false);

tests/sql/badges.sql.output

@@ -0,0 +1,82 @@
+ current_database 
+------------------
+ signalk
+(1 row)
+
+You are now connected to database "signalk" as user "username".
+Expanded display is on.
+-[ RECORD 1 ]
+vessel_id | t
+
+Insert new api.logbook for badges
+INSERT 0 2
+Set config
+-[ RECORD 1 ]----------------------------
+set_config | demo+kapla@openplotter.cloud
+
+Process badge
+-[ RECORD 1 ]-----+-
+badges_logbook_fn | 
+
+-[ RECORD 1 ]-----+-
+badges_logbook_fn | 
+
+-[ RECORD 1 ]--+-
+badges_geom_fn | 
+
+-[ RECORD 1 ]--+-
+badges_geom_fn | 
+
+Check badges for user
+-[ RECORD 1 ]-----+------------------
+jsonb_object_keys | Helmsman
+-[ RECORD 2 ]-----+------------------
+jsonb_object_keys | Wake Maker
+-[ RECORD 3 ]-----+------------------
+jsonb_object_keys | Balearic Sea
+-[ RECORD 4 ]-----+------------------
+jsonb_object_keys | Stormtrooper
+-[ RECORD 5 ]-----+------------------
+jsonb_object_keys | Gulf of Finland
+-[ RECORD 6 ]-----+------------------
+jsonb_object_keys | Helmsman
+-[ RECORD 7 ]-----+------------------
+jsonb_object_keys | Wake Maker
+-[ RECORD 8 ]-----+------------------
+jsonb_object_keys | Club Alaska
+-[ RECORD 9 ]-----+------------------
+jsonb_object_keys | Stormtrooper
+-[ RECORD 10 ]----+------------------
+jsonb_object_keys | Captain Award
+-[ RECORD 11 ]----+------------------
+jsonb_object_keys | Caribbean Sea
+-[ RECORD 12 ]----+------------------
+jsonb_object_keys | Gulf of Alaska
+-[ RECORD 13 ]----+------------------
+jsonb_object_keys | Gulf of Finland
+-[ RECORD 14 ]----+------------------
+jsonb_object_keys | Navigator Award
+-[ RECORD 15 ]----+------------------
+jsonb_object_keys | Tropical Traveler
+
+Check details from vessel_id kapla
+-[ RECORD 1 ]-+-----------------------------------------------------------------------------------------------------------------
+user_settings | {"boat" : "kapla", "recipient" : "First_kapla", "email" : "demo+kapla@openplotter.cloud", "pushover_key" : null}
+
+Insert new api.moorages for badges
+INSERT 0 2
+Set config
+-[ RECORD 1 ]---------------------------
+set_config | demo+aava@openplotter.cloud
+
+-[ RECORD 1 ]
+vessel_id | t
+
+Process badge
+-[ RECORD 1 ]------+-
+badges_moorages_fn | 
+
+Check details from vessel_id aava
+-[ RECORD 1 ]-+--------------------------------------------------------------------------------------------------------------
+user_settings | {"boat" : "aava", "recipient" : "first_aava", "email" : "demo+aava@openplotter.cloud", "pushover_key" : null}
+

tests/sql/cron_post_jobs.sql

@@ -0,0 +1,81 @@
+---------------------------------------------------------------------------
+-- Listing
+--
+
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+-- output display format
+\x on
+
+-- set user_id
+SELECT a.user_id as "user_id" FROM auth.accounts a WHERE a.email = 'demo+kapla@openplotter.cloud' \gset
+--\echo :"user_id"
+SELECT set_config('user.id', :'user_id', false) IS NOT NULL as user_id;
+
+-- set vessel_id
+SELECT v.vessel_id as "vessel_id" FROM auth.vessels v WHERE v.owner_email = 'demo+kapla@openplotter.cloud' \gset
+--\echo :"vessel_id"
+SELECT set_config('vessel.id', :'vessel_id', false) IS NOT NULL as vessel_id;
+
+-- Test logbook for user
+\echo 'logbook'
+SELECT count(*) FROM api.logbook WHERE vessel_id = current_setting('vessel.id', false);
+\echo 'logbook'
+SELECT name,_from_time IS NOT NULL AS _from_time,_to_time IS NOT NULL AS _to_time, track_geojson IS NOT NULL AS track_geojson, track_geom, distance,duration,avg_speed,max_speed,max_wind_speed,notes,extra FROM api.logbook WHERE vessel_id = current_setting('vessel.id', false);
+
+-- Test stays for user
+\echo 'stays'
+SELECT count(*) FROM api.stays WHERE vessel_id = current_setting('vessel.id', false);
+\echo 'stays'
+SELECT active,name IS NOT NULL AS name,geog,stay_code FROM api.stays WHERE vessel_id = current_setting('vessel.id', false);
+
+-- Test event logs view for user
+\echo 'eventlogs_view'
+SELECT count(*) from api.eventlogs_view;
+
+-- Test event logs view for user
+\echo 'stats_logs_fn'
+SELECT api.stats_logs_fn(null, null) INTO stats_jsonb;
+SELECT stats_logs_fn->'name' AS name,
+        stats_logs_fn->'count' AS count,
+        stats_logs_fn->'max_speed' As max_speed,
+        stats_logs_fn->'max_distance' AS max_distance,
+        stats_logs_fn->'max_duration' AS max_duration,
+        stats_logs_fn->'max_speed_id',
+        stats_logs_fn->'sum_distance',
+        stats_logs_fn->'sum_duration',
+        stats_logs_fn->'max_wind_speed',
+        stats_logs_fn->'max_distance_id',
+        stats_logs_fn->'max_duration_id',
+        stats_logs_fn->'max_wind_speed_id',
+        stats_logs_fn->'first_date' IS NOT NULL AS first_date,
+        stats_logs_fn->'last_date' IS NOT NULL AS last_date
+        FROM stats_jsonb;
+DROP TABLE stats_jsonb;
+SELECT api.stats_logs_fn('2022-01-01'::text,'2022-06-12'::text);
+
+-- Update logbook observations
+\echo 'update_logbook_observations_fn'
+SELECT extra FROM api.logbook l WHERE id = 1 AND vessel_id = current_setting('vessel.id', false);
+SELECT api.update_logbook_observations_fn(1, '{"observations":{"cloudCoverage":1}}'::TEXT);
+SELECT extra FROM api.logbook l WHERE id = 1 AND vessel_id = current_setting('vessel.id', false);
+
+\echo 'add tags to logbook'
+SELECT extra FROM api.logbook l WHERE id = 1 AND vessel_id = current_setting('vessel.id', false);
+SELECT api.update_logbook_observations_fn(1, '{"tags": ["tag_name"]}'::TEXT);
+SELECT extra FROM api.logbook l WHERE id = 1 AND vessel_id = current_setting('vessel.id', false);
+
+-- Check export
+--\echo 'check logbook export fn'
+--SELECT api.export_logbook_geojson_fn(1);
+--SELECT api.export_logbook_gpx_fn(1);
+--SELECT api.export_logbook_kml_fn(1);
+
+-- Check history
+--\echo 'monitoring history fn'
+--select api.monitoring_history_fn();
+--select api.monitoring_history_fn('24');

tests/sql/cron_post_jobs.sql.output

@@ -0,0 +1,112 @@
+ current_database 
+------------------
+ signalk
+(1 row)
+
+You are now connected to database "signalk" as user "username".
+Expanded display is on.
+-[ RECORD 1 ]
+user_id | t
+
+-[ RECORD 1 ]
+vessel_id | t
+
+logbook
+-[ RECORD 1 ]
+count | 2
+
+logbook
+-[ RECORD 1 ]--+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+name           | Pojoviken to Norra hamnen
+_from_time     | t
+_to_time       | t
+track_geojson  | t
+track_geom     | 0102000020E61000001C000000B0DEBBE0E68737404DA938FBF0094E40B0DEBBE0E68737404DA938FBF0094E4020D26F5F0786374030BB270F0B094E400C6E7ED60F843740AA60545227084E40D60FC48C03823740593CE27D42074E407B39D9F322803740984C158C4A064E4091ED7C3F357E3740898BB63D54054E40A8A1208B477C37404BA3DC9059044E404C5CB4EDA17A3740C4F856115B034E40A9A44E4013793740D8F0F44A59024E40E4839ECDAA773740211FF46C56014E405408D147067637408229F03B73004E40787AA52C43743740F90FE9B7AFFF4D40F8098D4D18723740C217265305FF4D4084E82303537037409A2D464AA0FE4D4022474DCE636F37402912396A72FE4D408351499D806E374088CFB02B40FE4D4076711B0DE06D3740B356C7040FFE4D404EAC66B0BC6E374058A835CD3BFE4D40D7A3703D0A6F3740D3E10EC15EFE4D4087602F277B6E3740A779C7293AFE4D4087602F277B6E3740A779C7293AFE4D402063EE5A426E3740B5A679C729FE4D40381DEE10EC6D37409ECA7C1A0AFE4D40E2C46A06CB6B37400A43F7BF36FD4D4075931804566E3740320BDAD125FD4D409A2D464AA06E37404A5658830AFD4D40029A081B9E6E37404A5658830AFD4D40
+distance       | 7.6447
+duration       | PT27M
+avg_speed      | 3.6357142857142852
+max_speed      | 6.1
+max_wind_speed | 22.1
+notes          | 
+extra          | {"metrics": {"propulsion.main.runTime": "PT10S"}, "observations": {"seaState": -1, "visibility": -1, "cloudCoverage": -1}, "avg_wind_speed": 14.549999999999999}
+-[ RECORD 2 ]--+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+name           | Norra hamnen to Ekenäs
+_from_time     | t
+_to_time       | t
+track_geojson  | t
+track_geom     | 0102000020E610000015000000029A081B9E6E37404A5658830AFD4D40029A081B9E6E37404A5658830AFD4D404806A6C0EF6C3740DA1B7C6132FD4D40FE65F7E461693740226C787AA5FC4D407DD3E10EC1663740B29DEFA7C6FB4D40898BB63D5465374068479724BCFA4D409A5271F6E1633740B6847CD0B3F94D40431CEBE236623740E9263108ACF84D402C6519E2585F37407E678EBFC7F74D4096218E75715B374027C5B45C23F74D402AA913D044583740968DE1C46AF64D405AF5B9DA8A5537407BEF829B9FF54D407449C2ABD253374086C954C1A8F44D407D1A0AB278543740F2B0506B9AF34D409D11A5BDC15737406688635DDCF24D4061C3D32B655937402CAF6F3ADCF14D408988888888583740B3319C58CDF04D4021FAC8C0145837408C94405DB7EF4D40B8F9593F105B37403DC0804BEDEE4D40DE4C5FE2A25D3740AE47E17A14EE4D40DE4C5FE2A25D3740AE47E17A14EE4D40
+distance       | 8.8968
+duration       | PT20M
+avg_speed      | 5.4523809523809526
+max_speed      | 6.5
+max_wind_speed | 37.2
+notes          | 
+extra          | {"metrics": {"propulsion.main.runTime": "PT11S"}, "observations": {"seaState": -1, "visibility": -1, "cloudCoverage": -1}, "avg_wind_speed": 10.476190476190478}
+
+stays
+-[ RECORD 1 ]
+count | 3
+
+stays
+-[ RECORD 1 ]-------------------------------------------------
+active    | t
+name      | f
+geog      | 
+stay_code | 2
+-[ RECORD 2 ]-------------------------------------------------
+active    | f
+name      | t
+geog      | 0101000020E6100000B0DEBBE0E68737404DA938FBF0094E40
+stay_code | 2
+-[ RECORD 3 ]-------------------------------------------------
+active    | f
+name      | t
+geog      | 0101000020E6100000029A081B9E6E37404A5658830AFD4D40
+stay_code | 4
+
+eventlogs_view
+-[ RECORD 1 ]
+count | 12
+
+stats_logs_fn
+SELECT 1
+-[ RECORD 1 ]+----------
+name         | "kapla"
+count        | 4
+max_speed    | 7.1
+max_distance | 8.8968
+max_duration | "PT1H11M"
+?column?     | 3
+?column?     | 30.1154
+?column?     | "PT2H43M"
+?column?     | 44.2
+?column?     | 2
+?column?     | 4
+?column?     | 4
+first_date   | t
+last_date    | t
+
+DROP TABLE
+-[ RECORD 1 ]-+-
+stats_logs_fn | 
+
+update_logbook_observations_fn
+-[ RECORD 1 ]-----------------------------------------------------------------------------------------------------------------------------------------------------------
+extra | {"metrics": {"propulsion.main.runTime": "PT10S"}, "observations": {"seaState": -1, "visibility": -1, "cloudCoverage": -1}, "avg_wind_speed": 14.549999999999999}
+
+-[ RECORD 1 ]------------------+--
+update_logbook_observations_fn | t
+
+-[ RECORD 1 ]----------------------------------------------------------------------------------------------------------------------------------------------------------
+extra | {"metrics": {"propulsion.main.runTime": "PT10S"}, "observations": {"seaState": -1, "visibility": -1, "cloudCoverage": 1}, "avg_wind_speed": 14.549999999999999}
+
+add tags to logbook
+-[ RECORD 1 ]----------------------------------------------------------------------------------------------------------------------------------------------------------
+extra | {"metrics": {"propulsion.main.runTime": "PT10S"}, "observations": {"seaState": -1, "visibility": -1, "cloudCoverage": 1}, "avg_wind_speed": 14.549999999999999}
+
+-[ RECORD 1 ]------------------+--
+update_logbook_observations_fn | t
+
+-[ RECORD 1 ]--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+extra | {"tags": ["tag_name"], "metrics": {"propulsion.main.runTime": "PT10S"}, "observations": {"seaState": -1, "visibility": -1, "cloudCoverage": 1}, "avg_wind_speed": 14.549999999999999}
+

tests/sql/cron_run_jobs.sql

@@ -0,0 +1,25 @@
+---------------------------------------------------------------------------
+-- Listing
+--
+
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+-- output display format
+\x on
+
+-- Check the number of process pending
+\echo 'Check the number of process pending'
+-- Should be 22
+SELECT count(*) as jobs from public.process_queue pq where pq.processed is null;
+--set role scheduler
+SELECT public.run_cron_jobs();
+-- Check any pending job
+SELECT count(*) as any_pending_jobs from public.process_queue pq where pq.processed is null;
+
+-- Check the number of metrics entries
+\echo 'Check the number of metrics entries'
+SELECT count(*) as metrics_count from api.metrics;

tests/sql/cron_run_jobs.sql.output

@@ -0,0 +1,21 @@
+ current_database 
+------------------
+ signalk
+(1 row)
+
+You are now connected to database "signalk" as user "username".
+Expanded display is on.
+Check the number of process pending
+-[ RECORD 1 ]
+jobs | 26
+
+-[ RECORD 1 ]-+-
+run_cron_jobs | 
+
+-[ RECORD 1 ]----+--
+any_pending_jobs | 2
+
+Check the number of metrics entries
+-[ RECORD 1 ]-+----
+metrics_count | 172
+

tests/sql/grafana.sql

@@ -0,0 +1,79 @@
+---------------------------------------------------------------------------
+-- Listing
+--
+
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+-- output display format
+\x on
+
+--
+-- grafana_auth
+SET ROLE grafana_auth;
+\echo 'ROLE grafana_auth current_setting'
+SELECT current_user, current_setting('user.email', true), current_setting('vessel.client_id', true), current_setting('vessel.id', true);
+
+--SELECT a.pass,v.name,m.client_id FROM auth.accounts a JOIN auth.vessels v ON a.email = 'demo+kapla@openplotter.cloud' AND a.role = 'user_role' AND cast(a.preferences->>'email_valid' as Boolean) = True AND v.owner_email = a.email JOIN api.metadata m ON m.vessel_id = v.vessel_id;
+--SELECT a.pass,v.name,m.client_id FROM auth.accounts a JOIN auth.vessels v ON a.email = 'demo+kapla@openplotter.cloud' AND a.role = 'user_role' AND v.owner_email = a.email JOIN api.metadata m ON m.vessel_id = v.vessel_id;
+\echo 'link vessel and user based on current_setting'
+SELECT v.name,m.client_id FROM auth.accounts a JOIN auth.vessels v ON a.role = 'user_role' AND v.owner_email = a.email JOIN api.metadata m ON m.vessel_id = v.vessel_id;
+
+\echo 'auth.accounts details'
+SELECT a.user_id IS NOT NULL AS user_id, a.email, a.first, a.last, a.pass IS NOT NULL AS pass, a.role, a.preferences->'telegram'->'chat' AS telegram, a.preferences->'pushover_user_key' AS pushover_user_key FROM auth.accounts AS a;
+\echo 'auth.vessels details'
+--SELECT 'SELECT ' || STRING_AGG('v.' || column_name, ', ') || ' FROM auth.vessels AS v' FROM information_schema.columns WHERE table_name = 'vessels' AND table_schema = 'auth' AND column_name NOT IN ('created_at', 'updated_at');
+SELECT v.vessel_id IS NOT NULL AS vessel_id, v.owner_email, v.mmsi, v.name, v.role FROM auth.vessels AS v;
+\echo 'api.metadata details'
+--
+SELECT m.id, m.name, m.mmsi, m.client_id, m.length, m.beam, m.height, m.ship_type, m.plugin_version, m.signalk_version, m.time IS NOT NULL AS time, m.active FROM api.metadata AS m;
+
+--
+-- grafana
+SET ROLE grafana;
+\echo 'ROLE grafana current_setting'
+
+\echo 'Set current_setting value'
+SET "user.email" = 'demo+kapla@openplotter.cloud';
+--SET vessel.client_id = 'vessels.urn:mrn:imo:mmsi:123456789';
+
+--select v.vessel_id FROM auth.vessels v WHERE v.owner_email = 'demo+kapla@openplotter.cloud';
+SELECT v.vessel_id as "vessel_id" FROM auth.vessels v WHERE v.owner_email = 'demo+kapla@openplotter.cloud' \gset
+--\echo :"vessel_id"
+SELECT set_config('vessel.id', :'vessel_id', false) IS NOT NULL as vessel_id;
+
+--SELECT current_user, current_setting('user.email', true), current_setting('vessel.client_id', true), current_setting('vessel.id', true);
+SELECT current_user, current_setting('user.email', true), current_setting('vessel.client_id', true);
+
+SELECT v.name AS __text, m.client_id AS __value FROM auth.vessels v JOIN api.metadata m ON v.owner_email = 'demo+kapla@openplotter.cloud' and m.vessel_id = v.vessel_id;
+
+\echo 'auth.vessels details'
+--SELECT * FROM auth.vessels v;
+SELECT v.vessel_id IS NOT NULL AS vessel_id, v.owner_email, v.mmsi, v.name, v.role FROM auth.vessels AS v;
+--SELECT * FROM api.metadata m;
+\echo 'api.metadata details'
+SELECT m.id, m.name, m.mmsi, m.client_id, m.length, m.beam, m.height, m.ship_type, m.plugin_version, m.signalk_version, m.time IS NOT NULL AS time, m.active FROM api.metadata AS m;
+
+\echo 'api.logs_view'
+--SELECT * FROM api.logbook l;
+--SELECT * FROM api.logs_view l;
+SELECT l.id, l.name, l.from, l.to, l.distance, l.duration, l._from_moorage_id, l._to_moorage_id FROM api.logs_view AS l;
+--SELECT * FROM api.log_view l;
+
+\echo 'api.stays'
+--SELECT * FROM api.stays s;
+SELECT m.id, m.vessel_id IS NOT NULL AS vessel_id, m.moorage_id, m.active, m.name IS NOT NULL AS name, m.latitude, m.longitude, m.geog, m.arrived IS NOT NULL AS arrived, m.departed IS NOT NULL AS departed, m.duration, m.stay_code, m.notes FROM api.stays AS m;
+
+\echo 'stays_view'
+--SELECT * FROM api.stays_view s;
+SELECT m.id, m.name IS NOT NULL AS name, m.moorage, m.moorage_id, m.duration, m.stayed_at, m.stayed_at_id, m.arrived IS NOT NULL AS arrived, m.departed IS NOT NULL AS departed, m.notes FROM api.stays_view AS m;
+
+\echo 'api.moorages'
+--SELECT * FROM api.moorages m;
+SELECT m.id, m.vessel_id IS NOT NULL AS vessel_id, m.name, m.country, m.stay_code, m.stay_duration, m.reference_count, m.latitude, m.longitude, m.geog, m.home_flag, m.notes FROM api.moorages AS m;
+
+\echo 'api.moorages_view'
+SELECT * FROM api.moorages_view s;

tests/sql/grafana.sql.output

@@ -0,0 +1,279 @@
+ current_database 
+------------------
+ signalk
+(1 row)
+
+You are now connected to database "signalk" as user "username".
+Expanded display is on.
+SET
+ROLE grafana_auth current_setting
+-[ RECORD 1 ]---+-------------
+current_user    | grafana_auth
+current_setting | 
+current_setting | 
+current_setting | 
+
+link vessel and user based on current_setting
+-[ RECORD 1 ]----------------------------------------------------------------
+name      | aava
+client_id | vessels.urn:mrn:imo:mmsi:787654321
+-[ RECORD 2 ]----------------------------------------------------------------
+name      | kapla
+client_id | vessels.urn:mrn:signalk:uuid:5b4f7543-7153-4840-b139-761310b242fd
+
+auth.accounts details
+-[ RECORD 1 ]-----+-----------------------------
+user_id           | t
+email             | demo+aava@openplotter.cloud
+first             | first_aava
+last              | last_aava
+pass              | t
+role              | user_role
+telegram          | 
+pushover_user_key | 
+-[ RECORD 2 ]-----+-----------------------------
+user_id           | t
+email             | demo+kapla@openplotter.cloud
+first             | First_kapla
+last              | Last_kapla
+pass              | t
+role              | user_role
+telegram          | 
+pushover_user_key | 
+
+auth.vessels details
+-[ RECORD 1 ]-----------------------------
+vessel_id   | t
+owner_email | demo+kapla@openplotter.cloud
+mmsi        | 
+name        | kapla
+role        | vessel_role
+-[ RECORD 2 ]-----------------------------
+vessel_id   | t
+owner_email | demo+aava@openplotter.cloud
+mmsi        | 787654321
+name        | aava
+role        | vessel_role
+
+api.metadata details
+-[ RECORD 1 ]---+------------------------------------------------------------------
+id              | 1
+name            | kapla
+mmsi            | 123456789
+client_id       | vessels.urn:mrn:signalk:uuid:5b4f7543-7153-4840-b139-761310b242fd
+length          | 12
+beam            | 10
+height          | 24
+ship_type       | 36
+plugin_version  | 0.0.1
+signalk_version | signalk_version
+time            | t
+active          | t
+-[ RECORD 2 ]---+------------------------------------------------------------------
+id              | 2
+name            | aava
+mmsi            | 787654321
+client_id       | vessels.urn:mrn:imo:mmsi:787654321
+length          | 12
+beam            | 10
+height          | 24
+ship_type       | 37
+plugin_version  | 1.0.2
+signalk_version | 1.20.0
+time            | t
+active          | t
+
+SET
+ROLE grafana current_setting
+Set current_setting value
+SET
+-[ RECORD 1 ]
+vessel_id | t
+
+-[ RECORD 1 ]---+-----------------------------
+current_user    | grafana
+current_setting | demo+kapla@openplotter.cloud
+current_setting | 
+
+-[ RECORD 1 ]--------------------------------------------------------------
+__text  | kapla
+__value | vessels.urn:mrn:signalk:uuid:5b4f7543-7153-4840-b139-761310b242fd
+
+auth.vessels details
+-[ RECORD 1 ]-----------------------------
+vessel_id   | t
+owner_email | demo+kapla@openplotter.cloud
+mmsi        | 
+name        | kapla
+role        | vessel_role
+
+api.metadata details
+-[ RECORD 1 ]---+------------------------------------------------------------------
+id              | 1
+name            | kapla
+mmsi            | 123456789
+client_id       | vessels.urn:mrn:signalk:uuid:5b4f7543-7153-4840-b139-761310b242fd
+length          | 12
+beam            | 10
+height          | 24
+ship_type       | 36
+plugin_version  | 0.0.1
+signalk_version | signalk_version
+time            | t
+active          | t
+
+api.logs_view
+-[ RECORD 1 ]----+-----------------------
+id               | 2
+name             | Norra hamnen to Ekenäs
+from             | Norra hamnen
+to               | Ekenäs
+distance         | 8.8968
+duration         | PT20M
+_from_moorage_id | 2
+_to_moorage_id   | 3
+-[ RECORD 2 ]----+-----------------------
+id               | 1
+name             | patch log name 3
+from             | patch moorage name 3
+to               | Norra hamnen
+distance         | 7.6447
+duration         | PT27M
+_from_moorage_id | 1
+_to_moorage_id   | 2
+
+api.stays
+-[ RECORD 1 ]--------------------------------------------------
+id         | 3
+vessel_id  | t
+moorage_id | 
+active     | t
+name       | f
+latitude   | 59.86
+longitude  | 23.365766666666666
+geog       | 
+arrived    | t
+departed   | f
+duration   | 
+stay_code  | 2
+notes      | 
+-[ RECORD 2 ]--------------------------------------------------
+id         | 1
+vessel_id  | t
+moorage_id | 1
+active     | f
+name       | t
+latitude   | 60.077666666666666
+longitude  | 23.530866666666668
+geog       | 0101000020E6100000B0DEBBE0E68737404DA938FBF0094E40
+arrived    | t
+departed   | t
+duration   | PT1M
+stay_code  | 2
+notes      | new stay note 3
+-[ RECORD 3 ]--------------------------------------------------
+id         | 2
+vessel_id  | t
+moorage_id | 2
+active     | f
+name       | t
+latitude   | 59.97688333333333
+longitude  | 23.4321
+geog       | 0101000020E6100000029A081B9E6E37404A5658830AFD4D40
+arrived    | t
+departed   | t
+duration   | PT2M
+stay_code  | 4
+notes      | 
+
+stays_view
+-[ RECORD 1 ]+---------------------
+id           | 2
+name         | t
+moorage      | Norra hamnen
+moorage_id   | 2
+duration     | PT2M
+stayed_at    | Dock
+stayed_at_id | 4
+arrived      | t
+departed     | t
+notes        | 
+-[ RECORD 2 ]+---------------------
+id           | 1
+name         | t
+moorage      | patch moorage name 3
+moorage_id   | 1
+duration     | PT1M
+stayed_at    | Anchor
+stayed_at_id | 2
+arrived      | t
+departed     | t
+notes        | new stay note 3
+
+api.moorages
+-[ RECORD 1 ]---+---------------------------------------------------
+id              | 1
+vessel_id       | t
+name            | patch moorage name 3
+country         | fi
+stay_code       | 2
+stay_duration   | PT1M
+reference_count | 1
+latitude        | 60.0776666666667
+longitude       | 23.5308666666667
+geog            | 0101000020E6100000B9DEBBE0E687374052A938FBF0094E40
+home_flag       | t
+notes           | new moorage note 3
+-[ RECORD 2 ]---+---------------------------------------------------
+id              | 2
+vessel_id       | t
+name            | Norra hamnen
+country         | fi
+stay_code       | 4
+stay_duration   | PT2M
+reference_count | 2
+latitude        | 59.9768833333333
+longitude       | 23.4321
+geog            | 0101000020E6100000029A081B9E6E3740455658830AFD4D40
+home_flag       | f
+notes           | 
+-[ RECORD 3 ]---+---------------------------------------------------
+id              | 3
+vessel_id       | t
+name            | Ekenäs
+country         | fi
+stay_code       | 1
+stay_duration   | PT0S
+reference_count | 1
+latitude        | 59.86
+longitude       | 23.3657666666667
+geog            | 0101000020E6100000E84C5FE2A25D3740AE47E17A14EE4D40
+home_flag       | f
+notes           | 
+
+api.moorages_view
+-[ RECORD 1 ]-------+---------------------
+id                  | 2
+moorage             | Norra hamnen
+default_stay        | Dock
+default_stay_id     | 4
+total_stay          | 0
+total_duration      | PT2M
+arrivals_departures | 2
+-[ RECORD 2 ]-------+---------------------
+id                  | 1
+moorage             | patch moorage name 3
+default_stay        | Anchor
+default_stay_id     | 2
+total_stay          | 0
+total_duration      | PT1M
+arrivals_departures | 1
+-[ RECORD 3 ]-------+---------------------
+id                  | 3
+moorage             | Ekenäs
+default_stay        | Unknown
+default_stay_id     | 1
+total_stay          | 0
+total_duration      | PT0S
+arrivals_departures | 1
+

tests/sql/logbook.sql

@@ -0,0 +1,38 @@
+---------------------------------------------------------------------------
+-- Listing
+--
+
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+-- output display format
+\x on
+
+\echo 'Validate logbook operation'
+-- set user_id
+SELECT a.user_id as "user_id" FROM auth.accounts a WHERE a.email = 'demo+kapla@openplotter.cloud' \gset
+--\echo :"user_id"
+SELECT set_config('user.id', :'user_id', false) IS NOT NULL as user_id;
+
+-- set vessel_id
+SELECT v.vessel_id as "vessel_id" FROM auth.vessels v WHERE v.owner_email = 'demo+kapla@openplotter.cloud' \gset
+--\echo :"vessel_id"
+SELECT set_config('vessel.id', :'vessel_id', false) IS NOT NULL as vessel_id;
+
+-- Delete logbook for user
+\echo 'logbook'
+SELECT count(*) FROM api.logbook WHERE vessel_id = current_setting('vessel.id', false);
+\echo 'logbook'
+SELECT name,_from_time IS NOT NULL AS _from_time,_to_time IS NOT NULL AS _to_time, track_geojson IS NOT NULL AS track_geojson, track_geom, distance,duration,avg_speed,max_speed,max_wind_speed,notes,extra FROM api.logbook WHERE vessel_id = current_setting('vessel.id', false);
+
+-- Delete logbook for user
+\echo 'Delete logbook for user kapla'
+SELECT api.delete_logbook_fn(5); -- delete Tropics Zone
+SELECT api.delete_logbook_fn(6); -- delete Alaska Zone
+
+-- Merge logbook for user
+\echo 'Merge logbook for user kapla'
+SELECT api.merge_logbook_fn(1,2);

tests/sql/logbook.sql.output

@@ -0,0 +1,83 @@
+ current_database 
+------------------
+ signalk
+(1 row)
+
+You are now connected to database "signalk" as user "username".
+Expanded display is on.
+Validate logbook operation
+-[ RECORD 1 ]
+user_id | t
+
+-[ RECORD 1 ]
+vessel_id | t
+
+logbook
+-[ RECORD 1 ]
+count | 4
+
+logbook
+-[ RECORD 1 ]--+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+name           | patch log name 3
+_from_time     | t
+_to_time       | t
+track_geojson  | t
+track_geom     | 0102000020E61000001C000000B0DEBBE0E68737404DA938FBF0094E40B0DEBBE0E68737404DA938FBF0094E4020D26F5F0786374030BB270F0B094E400C6E7ED60F843740AA60545227084E40D60FC48C03823740593CE27D42074E407B39D9F322803740984C158C4A064E4091ED7C3F357E3740898BB63D54054E40A8A1208B477C37404BA3DC9059044E404C5CB4EDA17A3740C4F856115B034E40A9A44E4013793740D8F0F44A59024E40E4839ECDAA773740211FF46C56014E405408D147067637408229F03B73004E40787AA52C43743740F90FE9B7AFFF4D40F8098D4D18723740C217265305FF4D4084E82303537037409A2D464AA0FE4D4022474DCE636F37402912396A72FE4D408351499D806E374088CFB02B40FE4D4076711B0DE06D3740B356C7040FFE4D404EAC66B0BC6E374058A835CD3BFE4D40D7A3703D0A6F3740D3E10EC15EFE4D4087602F277B6E3740A779C7293AFE4D4087602F277B6E3740A779C7293AFE4D402063EE5A426E3740B5A679C729FE4D40381DEE10EC6D37409ECA7C1A0AFE4D40E2C46A06CB6B37400A43F7BF36FD4D4075931804566E3740320BDAD125FD4D409A2D464AA06E37404A5658830AFD4D40029A081B9E6E37404A5658830AFD4D40
+distance       | 7.6447
+duration       | PT27M
+avg_speed      | 3.6357142857142852
+max_speed      | 6.1
+max_wind_speed | 22.1
+notes          | new log note 3
+extra          | {"tags": ["tag_name"], "metrics": {"propulsion.main.runTime": "PT10S"}, "observations": {"seaState": -1, "visibility": -1, "cloudCoverage": 1}, "avg_wind_speed": 14.549999999999999}
+-[ RECORD 2 ]--+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+name           | Norra hamnen to Ekenäs
+_from_time     | t
+_to_time       | t
+track_geojson  | t
+track_geom     | 0102000020E610000015000000029A081B9E6E37404A5658830AFD4D40029A081B9E6E37404A5658830AFD4D404806A6C0EF6C3740DA1B7C6132FD4D40FE65F7E461693740226C787AA5FC4D407DD3E10EC1663740B29DEFA7C6FB4D40898BB63D5465374068479724BCFA4D409A5271F6E1633740B6847CD0B3F94D40431CEBE236623740E9263108ACF84D402C6519E2585F37407E678EBFC7F74D4096218E75715B374027C5B45C23F74D402AA913D044583740968DE1C46AF64D405AF5B9DA8A5537407BEF829B9FF54D407449C2ABD253374086C954C1A8F44D407D1A0AB278543740F2B0506B9AF34D409D11A5BDC15737406688635DDCF24D4061C3D32B655937402CAF6F3ADCF14D408988888888583740B3319C58CDF04D4021FAC8C0145837408C94405DB7EF4D40B8F9593F105B37403DC0804BEDEE4D40DE4C5FE2A25D3740AE47E17A14EE4D40DE4C5FE2A25D3740AE47E17A14EE4D40
+distance       | 8.8968
+duration       | PT20M
+avg_speed      | 5.4523809523809526
+max_speed      | 6.5
+max_wind_speed | 37.2
+notes          | 
+extra          | {"metrics": {"propulsion.main.runTime": "PT11S"}, "observations": {"seaState": -1, "visibility": -1, "cloudCoverage": -1}, "avg_wind_speed": 10.476190476190478}
+-[ RECORD 3 ]--+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+name           | Tropics Zone
+_from_time     | t
+_to_time       | t
+track_geojson  | f
+track_geom     | 0102000020E610000002000000A4E85E0D58934FC000DC509B80052C40BC069B43D64553C090510727F3BD2940
+distance       | 123
+duration       | 
+avg_speed      | 
+max_speed      | 
+max_wind_speed | 
+notes          | 
+extra          | 
+-[ RECORD 4 ]--+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+name           | Alaska Zone
+_from_time     | t
+_to_time       | t
+track_geojson  | f
+track_geom     | 0102000020E610000002000000FDB11ED079F261C090C47F1861B84D40D3505124540B63C09C091C1C8D4A4C40
+distance       | 1234
+duration       | 
+avg_speed      | 
+max_speed      | 
+max_wind_speed | 
+notes          | 
+extra          | 
+
+Delete logbook for user kapla
+-[ RECORD 1 ]-----+--
+delete_logbook_fn | t
+
+-[ RECORD 1 ]-----+--
+delete_logbook_fn | t
+
+Merge logbook for user kapla
+-[ RECORD 1 ]----+-
+merge_logbook_fn | 
+

tests/sql/monitoring.sql

@@ -0,0 +1,62 @@
+---------------------------------------------------------------------------
+-- Listing
+--
+
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+-- output display format
+\x on
+
+\echo 'Set vessel_id and vessel.name'
+-- set vessel_id
+SELECT v.vessel_id as "vessel_id" FROM auth.vessels v WHERE v.owner_email = 'demo+kapla@openplotter.cloud' \gset
+--\echo :"vessel_id"
+SELECT set_config('vessel.id', :'vessel_id', false) IS NOT NULL as vessel_id;
+
+-- set name
+SELECT v.name as "name" FROM auth.vessels v WHERE v.owner_email = 'demo+kapla@openplotter.cloud' \gset
+--\echo :"vessel_id"
+SELECT set_config('vessel.name', :'name', false) IS NOT NULL as name;
+
+\echo 'Test monitoring_view for user'
+-- Test monitoring for user
+--select * from api.monitoring_view;
+select count(*) from api.monitoring_view;
+
+\echo 'Test monitoring_view2 for user'
+-- Test monitoring for user
+--select * from api.monitoring_view2;
+select count(*) from api.monitoring_view2;
+
+\echo 'Test monitoring_view3 for user'
+-- Test monitoring for user
+--select * from api.monitoring_view3;
+select count(*) from api.monitoring_view3;
+
+\echo 'Test monitoring_voltage for user'
+-- Test monitoring for user
+--select * from api.monitoring_voltage;
+select count(*) from api.monitoring_voltage;
+
+\echo 'Test monitoring_temperatures for user'
+-- Test monitoring for user
+--select * from api.monitoring_temperatures;
+select count(*) from api.monitoring_temperatures;
+
+\echo 'Test monitoring_humidity for user'
+-- Test monitoring for user
+--select * from api.monitoring_humidity;
+select count(*) from api.monitoring_humidity;
+
+\echo 'Test metersToKnots'
+select public.metersToKnots(1);
+
+\echo 'Test radiantToDegrees'
+select public.radiantToDegrees(1);
+
+\echo 'Test valToPercent'
+select public.valToPercent(1);

tests/sql/monitoring.sql.output

@@ -0,0 +1,50 @@
+ current_database 
+------------------
+ signalk
+(1 row)
+
+You are now connected to database "signalk" as user "username".
+Expanded display is on.
+Set vessel_id and vessel.name
+-[ RECORD 1 ]
+vessel_id | t
+
+-[ RECORD 1 ]
+name | t
+
+Test monitoring_view for user
+-[ RECORD 1 ]
+count | 1
+
+Test monitoring_view2 for user
+-[ RECORD 1 ]
+count | 21
+
+Test monitoring_view3 for user
+-[ RECORD 1 ]
+count | 3736
+
+Test monitoring_voltage for user
+-[ RECORD 1 ]
+count | 47
+
+Test monitoring_temperatures for user
+-[ RECORD 1 ]
+count | 120
+
+Test monitoring_humidity for user
+-[ RECORD 1 ]
+count | 0
+
+Test metersToKnots
+-[ RECORD 1 ]-+-----
+meterstoknots | 1.94
+
+Test radiantToDegrees
+-[ RECORD 1 ]----+---
+radianttodegrees | 57
+
+Test valToPercent
+-[ RECORD 1 ]+----
+valtopercent | 100
+

tests/sql/otp.sql

@@ -0,0 +1,26 @@
+---------------------------------------------------------------------------
+-- Listing
+--
+
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+-- output display format
+\x on
+
+--
+-- 
+\echo 'Count auth.accounts'
+SELECT count(*) from auth.accounts;
+\echo 'Settings auth.accounts'
+SELECT preferences->'email_notifications' as email_notifications from auth.accounts;
+SELECT preferences->'phone_notifications' as phone_notifications from auth.accounts;
+SELECT preferences->'telegram'->'chat'->'id' as telegram from auth.accounts;
+--SELECT preferences->'telegram'->'date' - INTERVAL 5 minutes from auth.accounts;
+
+SELECT count(*)
+    FROM auth.accounts
+    WHERE preferences->'telegram'->'chat'->'id' is null; 

tests/sql/otp.sql.output

@@ -0,0 +1,30 @@
+ current_database 
+------------------
+ signalk
+(1 row)
+
+You are now connected to database "signalk" as user "username".
+Expanded display is on.
+Count auth.accounts
+-[ RECORD 1 ]
+count | 2
+
+Settings auth.accounts
+-[ RECORD 1 ]-------+------
+email_notifications | false
+-[ RECORD 2 ]-------+------
+email_notifications | false
+
+-[ RECORD 1 ]-------+------
+phone_notifications | false
+-[ RECORD 2 ]-------+------
+phone_notifications | false
+
+-[ RECORD 1 ]--------
+telegram | 1234567890
+-[ RECORD 2 ]--------
+telegram | 9876543210
+
+-[ RECORD 1 ]
+count | 0
+

tests/sql/summary.sql

@@ -0,0 +1,94 @@
+---------------------------------------------------------------------------
+-- Listing
+--
+
+-- List current database
+select current_database();
+
+-- connect to the DB
+\c signalk
+
+-- output display format
+\x on
+
+-- List PostgreSQL version
+--SELECT version();
+-- check only version number to remove arch details
+SHOW server_version;
+
+-- List Postgis version
+SELECT postgis_full_version();
+
+-- List of installed extensions
+-- \dx
+--SELECT extname,extversion FROM pg_extension;
+SELECT e.extname AS "Name", e.extversion AS "Version", n.nspname AS "Schema", c.description AS "Description" 
+    FROM pg_catalog.pg_extension e 
+    LEFT JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace 
+    LEFT JOIN pg_catalog.pg_description c ON c.objoid = e.oid AND c.classoid = 'pg_catalog.pg_extension'::pg_catalog.regclass 
+    ORDER BY 1;
+
+-- List of installed extensions available for upgrade
+SELECT name, default_version, installed_version FROM pg_available_extensions where default_version <> installed_version;
+
+-- List Language
+\echo 'List Language'
+SELECT * FROM pg_language;
+
+-- List of databases
+-- ICU Missing entry in some system?
+--\l
+SELECT datname,datconnlimit,datcollate,datctype,datallowconn FROM pg_database;
+
+-- List of relations
+\echo 'List of relations'
+\dtables
+
+-- List tables from schema api
+select t.table_name as schema_api
+    from information_schema.tables t
+    where t.table_schema = 'api'
+        and t.table_type = 'BASE TABLE'
+    order by t.table_name;
+
+-- List tables from schema public
+select t.table_name as schema_public
+    from information_schema.tables t
+    where t.table_schema = 'public'
+        and t.table_type = 'BASE TABLE'
+    order by t.table_name;
+
+-- List tables from schema auth
+select t.table_name as schema_auth
+    from information_schema.tables t
+    where t.table_schema = 'auth'
+        and t.table_type = 'BASE TABLE'
+    order by t.table_name;
+
+-- List tables from schema jwt
+select t.table_name as schema_jwt
+    from information_schema.tables t
+    where t.table_schema = 'jwt'
+        and t.table_type = 'BASE TABLE'
+    order by t.table_name;
+
+-- List Row Security Policies - todo reduce and improve output
+\echo 'List Row Security Policies'
+select * from pg_policies;
+
+-- Test functions
+\echo 'Test nominatim reverse_geocode_py_fn'
+SELECT public.reverse_geocode_py_fn('nominatim', 1.4440116666666667, 38.82985166666667);
+\echo 'Test geoip reverse_geoip_py_fn'
+--SELECT reverse_geoip_py_fn('62.74.13.231');
+\echo 'Test opverpass API overpass_py_fn'
+SELECT public.overpass_py_fn(2.19917, 41.386873333333334); -- Port Olimpic
+SELECT public.overpass_py_fn(1.92574333333, 41.258915); -- Port de la Ginesta
+SELECT public.overpass_py_fn(23.4321, 59.9768833333333); -- Norra hamnen
+
+-- List details product versions
+SELECT api.versions_fn();
+SELECT * FROM api.versions_view;
+
+-- List application settings
+--SELECT * IS NOT NULl FROM public.app_settings;

tests/sql/summary.sql.output

@@ -0,0 +1,674 @@
+ current_database 
+------------------
+ signalk
+(1 row)
+
+You are now connected to database "signalk" as user "username".
+Expanded display is on.
+-[ RECORD 1 ]--+-------------------------------
+server_version | 16.3 (Debian 16.3-1.pgdg120+1)
+
+-[ RECORD 1 ]--------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+postgis_full_version | POSTGIS="3.4.2 c19ce56" [EXTENSION] PGSQL="160" GEOS="3.11.1-CAPI-1.17.1" PROJ="9.1.1 NETWORK_ENABLED=OFF URL_ENDPOINT=https://cdn.proj.org USER_WRITABLE_DIRECTORY=/var/lib/postgresql/.local/share/proj DATABASE_PATH=/usr/share/proj/proj.db" LIBXML="2.9.14" LIBJSON="0.16" LIBPROTOBUF="1.4.1" WAGYU="0.5.0 (Internal)"
+
+-[ RECORD 1 ]--------------------------------------------------------------------------------------
+Name        | citext
+Version     | 1.6
+Schema      | public
+Description | data type for case-insensitive character strings
+-[ RECORD 2 ]--------------------------------------------------------------------------------------
+Name        | jsonb_plpython3u
+Version     | 1.0
+Schema      | public
+Description | transform between jsonb and plpython3u
+-[ RECORD 3 ]--------------------------------------------------------------------------------------
+Name        | moddatetime
+Version     | 1.0
+Schema      | public
+Description | functions for tracking last modification time
+-[ RECORD 4 ]--------------------------------------------------------------------------------------
+Name        | pg_stat_statements
+Version     | 1.10
+Schema      | public
+Description | track planning and execution statistics of all SQL statements executed
+-[ RECORD 5 ]--------------------------------------------------------------------------------------
+Name        | pgcrypto
+Version     | 1.3
+Schema      | public
+Description | cryptographic functions
+-[ RECORD 6 ]--------------------------------------------------------------------------------------
+Name        | plpgsql
+Version     | 1.0
+Schema      | pg_catalog
+Description | PL/pgSQL procedural language
+-[ RECORD 7 ]--------------------------------------------------------------------------------------
+Name        | plpython3u
+Version     | 1.0
+Schema      | pg_catalog
+Description | PL/Python3U untrusted procedural language
+-[ RECORD 8 ]--------------------------------------------------------------------------------------
+Name        | postgis
+Version     | 3.4.2
+Schema      | public
+Description | PostGIS geometry and geography spatial types and functions
+-[ RECORD 9 ]--------------------------------------------------------------------------------------
+Name        | timescaledb
+Version     | 2.15.3
+Schema      | public
+Description | Enables scalable inserts and complex queries for time-series data (Community Edition)
+-[ RECORD 10 ]-------------------------------------------------------------------------------------
+Name        | uuid-ossp
+Version     | 1.1
+Schema      | public
+Description | generate universally unique identifiers (UUIDs)
+
+(0 rows)
+
+List Language
+-[ RECORD 1 ]-+-----------
+oid           | 12
+lanname       | internal
+lanowner      | 10
+lanispl       | f
+lanpltrusted  | f
+lanplcallfoid | 0
+laninline     | 0
+lanvalidator  | 2246
+lanacl        | 
+-[ RECORD 2 ]-+-----------
+oid           | 13
+lanname       | c
+lanowner      | 10
+lanispl       | f
+lanpltrusted  | f
+lanplcallfoid | 0
+laninline     | 0
+lanvalidator  | 2247
+lanacl        | 
+-[ RECORD 3 ]-+-----------
+oid           | 14
+lanname       | sql
+lanowner      | 10
+lanispl       | f
+lanpltrusted  | t
+lanplcallfoid | 0
+laninline     | 0
+lanvalidator  | 2248
+lanacl        | 
+-[ RECORD 4 ]-+-----------
+oid           | 13568
+lanname       | plpgsql
+lanowner      | 10
+lanispl       | t
+lanpltrusted  | t
+lanplcallfoid | 13565
+laninline     | 13566
+lanvalidator  | 13567
+lanacl        | 
+-[ RECORD 5 ]-+-----------
+oid           | 18168
+lanname       | plpython3u
+lanowner      | 10
+lanispl       | t
+lanpltrusted  | t
+lanplcallfoid | 18165
+laninline     | 18166
+lanvalidator  | 18167
+lanacl        | 
+
+-[ RECORD 1 ]+-----------
+datname      | postgres
+datconnlimit | -1
+datcollate   | en_US.utf8
+datctype     | en_US.utf8
+datallowconn | t
+-[ RECORD 2 ]+-----------
+datname      | template1
+datconnlimit | -1
+datcollate   | en_US.utf8
+datctype     | en_US.utf8
+datallowconn | t
+-[ RECORD 3 ]+-----------
+datname      | template0
+datconnlimit | -1
+datcollate   | en_US.utf8
+datctype     | en_US.utf8
+datallowconn | f
+-[ RECORD 4 ]+-----------
+datname      | signalk
+datconnlimit | 100
+datcollate   | en_US.utf8
+datctype     | en_US.utf8
+datallowconn | t
+
+List of relations
+List of relations
+-[ RECORD 1 ]---------------------------------
+Schema | public
+Name   | aistypes
+Type   | table
+Owner  | username
+-[ RECORD 2 ]---------------------------------
+Schema | public
+Name   | app_settings
+Type   | table
+Owner  | username
+-[ RECORD 3 ]---------------------------------
+Schema | public
+Name   | badges
+Type   | table
+Owner  | username
+-[ RECORD 4 ]---------------------------------
+Schema | public
+Name   | email_templates
+Type   | table
+Owner  | username
+-[ RECORD 5 ]---------------------------------
+Schema | public
+Name   | geocoders
+Type   | table
+Owner  | username
+-[ RECORD 6 ]---------------------------------
+Schema | public
+Name   | iso3166
+Type   | table
+Owner  | username
+-[ RECORD 7 ]---------------------------------
+Schema | public
+Name   | mid
+Type   | table
+Owner  | username
+-[ RECORD 8 ]---------------------------------
+Schema | public
+Name   | ne_10m_geography_marine_polys
+Type   | table
+Owner  | username
+-[ RECORD 9 ]---------------------------------
+Schema | public
+Name   | ne_10m_geography_marine_polys_gid_seq
+Type   | sequence
+Owner  | username
+-[ RECORD 10 ]--------------------------------
+Schema | public
+Name   | process_queue
+Type   | table
+Owner  | username
+-[ RECORD 11 ]--------------------------------
+Schema | public
+Name   | process_queue_id_seq
+Type   | sequence
+Owner  | username
+-[ RECORD 12 ]--------------------------------
+Schema | public
+Name   | spatial_ref_sys
+Type   | table
+Owner  | username
+
+-[ RECORD 1 ]--------
+schema_api | logbook
+-[ RECORD 2 ]--------
+schema_api | metadata
+-[ RECORD 3 ]--------
+schema_api | metrics
+-[ RECORD 4 ]--------
+schema_api | moorages
+-[ RECORD 5 ]--------
+schema_api | stays
+-[ RECORD 6 ]--------
+schema_api | stays_at
+
+-[ RECORD 1 ]-+------------------------------
+schema_public | aistypes
+-[ RECORD 2 ]-+------------------------------
+schema_public | app_settings
+-[ RECORD 3 ]-+------------------------------
+schema_public | badges
+-[ RECORD 4 ]-+------------------------------
+schema_public | email_templates
+-[ RECORD 5 ]-+------------------------------
+schema_public | geocoders
+-[ RECORD 6 ]-+------------------------------
+schema_public | iso3166
+-[ RECORD 7 ]-+------------------------------
+schema_public | mid
+-[ RECORD 8 ]-+------------------------------
+schema_public | ne_10m_geography_marine_polys
+-[ RECORD 9 ]-+------------------------------
+schema_public | process_queue
+-[ RECORD 10 ]+------------------------------
+schema_public | spatial_ref_sys
+
+-[ RECORD 1 ]---------
+schema_auth | accounts
+-[ RECORD 2 ]---------
+schema_auth | otp
+-[ RECORD 3 ]---------
+schema_auth | users
+-[ RECORD 4 ]---------
+schema_auth | vessels
+
+(0 rows)
+
+List Row Security Policies
+-[ RECORD 1 ]------------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metadata
+policyname | admin_all
+permissive | PERMISSIVE
+roles      | {username}
+cmd        | ALL
+qual       | true
+with_check | true
+-[ RECORD 2 ]------------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metadata
+policyname | api_vessel_role
+permissive | PERMISSIVE
+roles      | {vessel_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | true
+-[ RECORD 3 ]------------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metadata
+policyname | api_user_role
+permissive | PERMISSIVE
+roles      | {user_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, true))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 4 ]------------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metadata
+policyname | api_scheduler_role
+permissive | PERMISSIVE
+roles      | {scheduler}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 5 ]------------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metadata
+policyname | grafana_role
+permissive | PERMISSIVE
+roles      | {grafana}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | false
+-[ RECORD 6 ]------------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metadata
+policyname | grafana_proxy_role
+permissive | PERMISSIVE
+roles      | {grafana_auth}
+cmd        | ALL
+qual       | true
+with_check | false
+-[ RECORD 7 ]------------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metrics
+policyname | admin_all
+permissive | PERMISSIVE
+roles      | {username}
+cmd        | ALL
+qual       | true
+with_check | true
+-[ RECORD 8 ]------------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metrics
+policyname | api_vessel_role
+permissive | PERMISSIVE
+roles      | {vessel_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | true
+-[ RECORD 9 ]------------------------------------------------------------------------------------------------------------------------------
+schemaname | auth
+tablename  | vessels
+policyname | grafana_proxy_role
+permissive | PERMISSIVE
+roles      | {grafana_auth}
+cmd        | ALL
+qual       | true
+with_check | false
+-[ RECORD 10 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metrics
+policyname | api_user_role
+permissive | PERMISSIVE
+roles      | {user_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, true))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 11 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metrics
+policyname | api_scheduler_role
+permissive | PERMISSIVE
+roles      | {scheduler}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 12 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metrics
+policyname | grafana_role
+permissive | PERMISSIVE
+roles      | {grafana}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | false
+-[ RECORD 13 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | metrics
+policyname | api_anonymous_role
+permissive | PERMISSIVE
+roles      | {api_anonymous}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | false
+-[ RECORD 14 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | logbook
+policyname | admin_all
+permissive | PERMISSIVE
+roles      | {username}
+cmd        | ALL
+qual       | true
+with_check | true
+-[ RECORD 15 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | logbook
+policyname | api_vessel_role
+permissive | PERMISSIVE
+roles      | {vessel_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | true
+-[ RECORD 16 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | auth
+tablename  | accounts
+policyname | admin_all
+permissive | PERMISSIVE
+roles      | {username}
+cmd        | ALL
+qual       | true
+with_check | true
+-[ RECORD 17 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | logbook
+policyname | api_user_role
+permissive | PERMISSIVE
+roles      | {user_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, true))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 18 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | logbook
+policyname | api_scheduler_role
+permissive | PERMISSIVE
+roles      | {scheduler}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 19 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | logbook
+policyname | grafana_role
+permissive | PERMISSIVE
+roles      | {grafana}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | false
+-[ RECORD 20 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | logbook
+policyname | api_anonymous_role
+permissive | PERMISSIVE
+roles      | {api_anonymous}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | false
+-[ RECORD 21 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | stays
+policyname | admin_all
+permissive | PERMISSIVE
+roles      | {username}
+cmd        | ALL
+qual       | true
+with_check | true
+-[ RECORD 22 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | stays
+policyname | api_vessel_role
+permissive | PERMISSIVE
+roles      | {vessel_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | true
+-[ RECORD 23 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | logbook
+policyname | logbook_qgis_role
+permissive | PERMISSIVE
+roles      | {qgis_role}
+cmd        | ALL
+qual       | true
+with_check | false
+-[ RECORD 24 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | public
+tablename  | process_queue
+policyname | public_maplapse_role
+permissive | PERMISSIVE
+roles      | {maplapse_role}
+cmd        | ALL
+qual       | true
+with_check | true
+-[ RECORD 25 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | stays
+policyname | api_user_role
+permissive | PERMISSIVE
+roles      | {user_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, true))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 26 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | stays
+policyname | api_scheduler_role
+permissive | PERMISSIVE
+roles      | {scheduler}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 27 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | stays
+policyname | grafana_role
+permissive | PERMISSIVE
+roles      | {grafana}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | false
+-[ RECORD 28 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | stays
+policyname | api_anonymous_role
+permissive | PERMISSIVE
+roles      | {api_anonymous}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | false
+-[ RECORD 29 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | moorages
+policyname | admin_all
+permissive | PERMISSIVE
+roles      | {username}
+cmd        | ALL
+qual       | true
+with_check | true
+-[ RECORD 30 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | moorages
+policyname | api_vessel_role
+permissive | PERMISSIVE
+roles      | {vessel_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | true
+-[ RECORD 31 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | moorages
+policyname | api_user_role
+permissive | PERMISSIVE
+roles      | {user_role}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, true))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 32 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | moorages
+policyname | api_scheduler_role
+permissive | PERMISSIVE
+roles      | {scheduler}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | (vessel_id = current_setting('vessel.id'::text, false))
+-[ RECORD 33 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | moorages
+policyname | grafana_role
+permissive | PERMISSIVE
+roles      | {grafana}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | false
+-[ RECORD 34 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | api
+tablename  | moorages
+policyname | api_anonymous_role
+permissive | PERMISSIVE
+roles      | {api_anonymous}
+cmd        | ALL
+qual       | (vessel_id = current_setting('vessel.id'::text, false))
+with_check | false
+-[ RECORD 35 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | auth
+tablename  | vessels
+policyname | admin_all
+permissive | PERMISSIVE
+roles      | {username}
+cmd        | ALL
+qual       | true
+with_check | true
+-[ RECORD 36 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | auth
+tablename  | vessels
+policyname | api_user_role
+permissive | PERMISSIVE
+roles      | {user_role}
+cmd        | ALL
+qual       | ((vessel_id = current_setting('vessel.id'::text, true)) AND ((owner_email)::text = current_setting('user.email'::text, true)))
+with_check | ((vessel_id = current_setting('vessel.id'::text, true)) AND ((owner_email)::text = current_setting('user.email'::text, true)))
+-[ RECORD 37 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | auth
+tablename  | vessels
+policyname | grafana_role
+permissive | PERMISSIVE
+roles      | {grafana}
+cmd        | ALL
+qual       | ((owner_email)::text = current_setting('user.email'::text, true))
+with_check | false
+-[ RECORD 38 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | auth
+tablename  | accounts
+policyname | api_user_role
+permissive | PERMISSIVE
+roles      | {user_role}
+cmd        | ALL
+qual       | ((email)::text = current_setting('user.email'::text, true))
+with_check | ((email)::text = current_setting('user.email'::text, true))
+-[ RECORD 39 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | auth
+tablename  | accounts
+policyname | api_scheduler_role
+permissive | PERMISSIVE
+roles      | {scheduler}
+cmd        | ALL
+qual       | ((email)::text = current_setting('user.email'::text, true))
+with_check | ((email)::text = current_setting('user.email'::text, true))
+-[ RECORD 40 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | auth
+tablename  | accounts
+policyname | grafana_proxy_role
+permissive | PERMISSIVE
+roles      | {grafana_auth}
+cmd        | ALL
+qual       | true
+with_check | false
+-[ RECORD 41 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | public
+tablename  | process_queue
+policyname | admin_all
+permissive | PERMISSIVE
+roles      | {username}
+cmd        | ALL
+qual       | true
+with_check | true
+-[ RECORD 42 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | public
+tablename  | process_queue
+policyname | api_vessel_role
+permissive | PERMISSIVE
+roles      | {vessel_role}
+cmd        | ALL
+qual       | ((ref_id = current_setting('user.id'::text, true)) OR (ref_id = current_setting('vessel.id'::text, true)))
+with_check | true
+-[ RECORD 43 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | public
+tablename  | process_queue
+policyname | api_user_role
+permissive | PERMISSIVE
+roles      | {user_role}
+cmd        | ALL
+qual       | ((ref_id = current_setting('user.id'::text, true)) OR (ref_id = current_setting('vessel.id'::text, true)))
+with_check | ((ref_id = current_setting('user.id'::text, true)) OR (ref_id = current_setting('vessel.id'::text, true)))
+-[ RECORD 44 ]-----------------------------------------------------------------------------------------------------------------------------
+schemaname | public
+tablename  | process_queue
+policyname | api_scheduler_role
+permissive | PERMISSIVE
+roles      | {scheduler}
+cmd        | ALL
+qual       | true
+with_check | false
+
+Test nominatim reverse_geocode_py_fn
+-[ RECORD 1 ]---------+----------------------------------------
+reverse_geocode_py_fn | {"name": "Spain", "country_code": "es"}
+
+Test geoip reverse_geoip_py_fn
+Test opverpass API overpass_py_fn
+-[ RECORD 1 ]--+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+overpass_py_fn | {"fee": "yes", "vhf": "09", "name": "Port Olímpic", "phone": "+34 933561016", "leisure": "marina", "website": "https://portolimpic.barcelona/", "wikidata": "Q171204", "wikipedia": "ca:Port Olímpic de Barcelona", "addr:street": "Moll de Xaloc", "power_supply": "yes", "seamark:type": "harbour", "addr:postcode": "08005", "internet_access": "wlan", "wikimedia_commons": "Category:Port Olímpic (Barcelona)", "sanitary_dump_station": "yes", "seamark:harbour:category": "marina"}
+
+-[ RECORD 1 ]--+----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+overpass_py_fn | {"name": "Port de la Ginesta", "type": "multipolygon", "leisure": "marina", "name:ca": "Port de la Ginesta", "wikidata": "Q16621038", "wikipedia": "ca:Port Ginesta"}
+
+-[ RECORD 1 ]--+----------------------------------------------
+overpass_py_fn | {"name": "Norra hamnen", "leisure": "marina"}
+
+-[ RECORD 1 ]----------------------------------------------------------------------------------------------------------------------------------------------
+versions_fn | {"api_version" : "0.7.4", "sys_version" : "PostgreSQL 16.3", "timescaledb" : "2.15.3", "postgis" : "3.4.2", "postgrest" : "PostgREST 12.2.2"}
+
+-[ RECORD 1 ]-----------------
+api_version | 0.7.4
+sys_version | PostgreSQL 16.3
+timescaledb | 2.15.3
+postgis     | 3.4.2
+postgrest   | PostgREST 12.2.2
+