Batch Upload Locations

// Continuous location streaming for fleet management
const trackFleetVehicle = async (tripId, gpsReceiver) => {
  const locationBuffer = [];
  const BATCH_SIZE = 10;
  const UPLOAD_INTERVAL = 30; // seconds
  
  gpsReceiver.on('location', (location) => {
    locationBuffer.push({
      latitude: location.lat,
      longitude: location.lng,
      timestamp: new Date().toISOString(),
      speed_kmh: location.speed,
      heading: location.course,
      accuracy_meters: location.accuracy
    });
    
    // Upload when buffer reaches batch size
    if (locationBuffer.length >= BATCH_SIZE) {
      uploadBatch(tripId, locationBuffer.splice(0, BATCH_SIZE));
    }
  });
  
  // Upload remaining locations periodically
  setInterval(() => {
    if (locationBuffer.length > 0) {
      uploadBatch(tripId, locationBuffer.splice(0));
    }
  }, UPLOAD_INTERVAL * 1000);
};

const uploadBatch = async (tripId, locations) => {
  try {
    const result = await client.locations.batchUpload(tripId, locations);
    
    // Alert on safety events
    if (result.events_detected.length > 0) {
      result.events_detected.forEach(event => {
        if (event.severity === 'high') {
          sendAlertToFleetManager(tripId, event);
        }
      });
    }
  } catch (error) {
    console.error('Failed to upload batch:', error);
  }
};

# Background location sync for mobile applications
import asyncio
import sqlite3
from datetime import datetime

class LocationSyncManager:
    def __init__(self, client, db_path):
        self.client = client
        self.db = sqlite3.connect(db_path)
        self.setup_database()
    
    def setup_database(self):
        self.db.execute('''
            CREATE TABLE IF NOT EXISTS pending_locations (
                id INTEGER PRIMARY KEY,
                trip_id TEXT,
                latitude REAL,
                longitude REAL,
                timestamp TEXT,
                speed_kmh REAL,
                synced BOOLEAN DEFAULT 0
            )
        ''')
    
    async def sync_pending_locations(self):
        """Sync all pending locations to the server"""
        cursor = self.db.execute(
            "SELECT trip_id, latitude, longitude, timestamp, speed_kmh, id FROM pending_locations WHERE synced = 0"
        )
        
        # Group by trip_id for batch uploads
        trips_data = {}
        location_ids = []
        
        for row in cursor.fetchall():
            trip_id = row[0]
            location_data = {
                'latitude': row[1],
                'longitude': row[2], 
                'timestamp': row[3],
                'speed_kmh': row[4]
            }
            
            if trip_id not in trips_data:
                trips_data[trip_id] = []
            
            trips_data[trip_id].append(location_data)
            location_ids.append(row[5])
        
        # Upload each trip's locations
        for trip_id, locations in trips_data.items():
            try:
                await self.client.locations.batch_upload(
                    trip_id=trip_id,
                    locations=locations
                )
                
                # Mark as synced
                placeholders = ','.join(['?' for _ in location_ids])
                self.db.execute(
                    f"UPDATE pending_locations SET synced = 1 WHERE id IN ({placeholders})",
                    location_ids
                )
                self.db.commit()
                
            except Exception as e:
                print(f"Failed to sync locations for trip {trip_id}: {e}")

# Usage
sync_manager = LocationSyncManager(client, 'location_cache.db')
await sync_manager.sync_pending_locations()

// GPS tracker integration for IoT devices
package main

import (
    "context"
    "encoding/json"
    "log"
    "time"
    "github.com/bookovia/go-sdk"
)

type GPSTracker struct {
    client     *bookovia.Client
    deviceID   string
    bufferSize int
    buffer     []*bookovia.Location
}

func NewGPSTracker(client *bookovia.Client, deviceID string) *GPSTracker {
    return &GPSTracker{
        client:     client,
        deviceID:   deviceID,
        bufferSize: 50,
        buffer:     make([]*bookovia.Location, 0, 50),
    }
}

func (g *GPSTracker) ProcessGPSMessage(tripID string, gpsData []byte) error {
    var location struct {
        Lat       float64 `json:"lat"`
        Lng       float64 `json:"lng"`
        Speed     float64 `json:"speed"`
        Heading   float64 `json:"heading"`
        Timestamp int64   `json:"timestamp"`
    }
    
    if err := json.Unmarshal(gpsData, &location); err != nil {
        return err
    }
    
    // Add to buffer
    g.buffer = append(g.buffer, &bookovia.Location{
        Latitude:  location.Lat,
        Longitude: location.Lng,
        Timestamp: time.Unix(location.Timestamp, 0),
        SpeedKmh:  location.Speed,
        Heading:   location.Heading,
    })
    
    // Upload when buffer is full
    if len(g.buffer) >= g.bufferSize {
        return g.flushBuffer(tripID)
    }
    
    return nil
}

func (g *GPSTracker) flushBuffer(tripID string) error {
    if len(g.buffer) == 0 {
        return nil
    }
    
    result, err := g.client.Locations.BatchUpload(context.Background(), &bookovia.BatchUploadRequest{
        TripID:    tripID,
        Locations: g.buffer,
        DeviceInfo: &bookovia.DeviceInfo{
            DeviceID:    g.deviceID,
            DeviceModel: "GPS Tracker v2",
            OSVersion:   "embedded",
            AppVersion:  "1.0.0",
        },
    })
    
    if err != nil {
        return err
    }
    
    log.Printf("Uploaded %d locations, detected %d events", 
        result.ProcessedCount, len(result.EventsDetected))
    
    // Clear buffer
    g.buffer = g.buffer[:0]
    return nil
}