stationsByUuids

Websocket connection to receive state changes for given Station IDs

stationsByUuids(
  uuids: [ID!]!
): [Station!]

Arguments

stationsByUuids.uuids ● [ID!]! non-null scalar common

Type

Station object stations

Entity representing an RTK reference station

Code Samples

JavaScript

const subscription = `
subscription StationsByUuidsSubscription($uuids: [ID!]!) {
  stationsByUuids(uuids: $uuids) {
    uuid
    name
    status
    position {
      llaDec {
        lat
        lon
        alt
      }
    }
  }
}
`;

const variables = {
  "uuids": [
    "station-uuid-1",
    "station-uuid-2"
  ]
};

// WebSocket subscription using graphql-transport-ws protocol
const ws = new WebSocket('wss://graphql.pointonenav.com/subscriptions', 'graphql-transport-ws');

ws.onopen = () => {
  // Initialize connection
  ws.send(JSON.stringify({
    type: 'connection_init',
    payload: {
      Authorization: 'Bearer YOUR_TOKEN'
    }
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);

  // Wait for connection acknowledgement before subscribing
  if (data.type === 'connection_ack') {
    ws.send(JSON.stringify({
      id: '1',
      type: 'subscribe',
      payload: {
        query: subscription,
        variables: variables
      }
    }));
    return;
  }

  console.log(data);
};

Python

import requests
import json
import websocket
import threading

subscribed = False

subscription = """
subscription StationsByUuidsSubscription($uuids: [ID!]!) {
  stationsByUuids(uuids: $uuids) {
    uuid
    name
    status
    position {
      llaDec {
        lat
        lon
        alt
      }
    }
  }
}
"""

variables = {
    "uuids": [
        "station-uuid-1",
        "station-uuid-2"
    ]
}

def on_message(ws, message):
    global subscribed
    data = json.loads(message)
    print(json.dumps(data, indent=2))

    # Subscribe after receiving connection acknowledgement
    if not subscribed and data.get('type') == 'connection_ack':
        ws.send(json.dumps({
            'id': '1',
            'type': 'subscribe',
            'payload': {
                'query': subscription,
                'variables': variables
            }
        }))
        subscribed = True

def on_open(ws):
    # Initialize connection
    ws.send(json.dumps({
        'type': 'connection_init',
        'payload': {
            'Authorization': 'Bearer YOUR_TOKEN'
        }
    }))

ws = websocket.WebSocketApp('wss://graphql.pointonenav.com/subscriptions',
                          subprotocols=["graphql-transport-ws"],
                          on_message=on_message,
                          on_open=on_open)
ws.run_forever()

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
    "github.com/gorilla/websocket"
)

type GraphQLRequest struct {
    Query     string      `json:"query"`
    Variables interface{} `json:"variables"`
}

type WSMessage struct {
    Type    string      `json:"type"`
    ID      string      `json:"id,omitempty"`
    Payload interface{} `json:"payload,omitempty"`
}

func main() {
    subscription := `
subscription StationsByUuidsSubscription($uuids: [ID!]!) {
  stationsByUuids(uuids: $uuids) {
    uuid
    name
    status
    position {
      llaDec {
        lat
        lon
        alt
      }
    }
  }
}`

    variables := map[string]interface{}{
        "uuids": ["station-uuid-1","station-uuid-2"],
    }

    u, _ := url.Parse("wss://graphql.pointonenav.com/subscriptions")
    
    dialer := websocket.Dialer{
        Subprotocols: []string{"graphql-transport-ws"},
    }

    c, _, _ := dialer.Dial(u.String(), nil)
    defer c.Close()
    
    // Initialize connection
    initMsg := WSMessage{
        Type: "connection_init",
        Payload: map[string]string{
            "Authorization": "Bearer YOUR_TOKEN",
        },
    }
    c.WriteJSON(initMsg)
    
    // Prepare subscription message (sent after connection acknowledgement)
    startMsg := WSMessage{
        Type: "subscribe",
        ID:   "1",
        Payload: GraphQLRequest{
            Query:     subscription,
            Variables: variables,
        },
    }
    
    // Read messages, wait for connection acknowledgement then subscribe
    ackReceived := false
    for {
        var msg map[string]interface{}
        err := c.ReadJSON(&msg)
        if err != nil {
            break
        }

        if !ackReceived {
            if msgType, ok := msg["type"].(string); ok && msgType == "connection_ack" {
                ackReceived = true
                // Send subscription using graphql-transport-ws protocol
                c.WriteJSON(startMsg)
            }
        }

        fmt.Printf("%+v\n", msg)
    }
}