Allow to specify a map id in ulogger, to allow writing tracks to a shared map

Author: digitaltom

app/models/layer.rb

@@ -10,7 +10,7 @@ class Layer
   scope :geojson, -> { where(type: "geojson") }
   scope :overpass, -> { where(type: "overpass") }
 
-  field :type
+  field :type, default: "geojson"
   field :name
   field :query
   field :heatmap, type: Boolean

engines/ulogger/README.md

@@ -1,30 +1,32 @@
 # µlogger API for Mapforge
 
-* App: https://f-droid.org/packages/net.fabiszewski.ulogger
-* Original server project: https://github.com/bfabiszewski/ulogger-server
-* Client project: https://github.com/bfabiszewski/ulogger-android
+* App: [https://f-droid.org/packages/net.fabiszewski.ulogger](https://f-droid.org/packages/net.fabiszewski.ulogger)
+* Original server project: [https://github.com/bfabiszewski/ulogger-server](https://github.com/bfabiszewski/ulogger-server)
+* Client project: [https://github.com/bfabiszewski/ulogger-android](https://github.com/bfabiszewski/ulogger-android)
 
 ![Mapforge µlogger track](https://github.com/digitaltom/mapforge/blob/main/engines/ulogger/docs/track.jpg?raw=true)
 
 ## Usage
 
 To use the µlogger app with mapforge.org, you need to go to its settings,
-and use `https://mapforge.org/ulogger` as server url, and if you want your track to get assigned to your account, add your mapforge login account email as user name (no password).
+and use `https://mapforge.org/ulogger` as server url, and if you want your track to get assigned to your account, add your mapforge **email** as user name (any password).
 
 ![Screenshot_20250616-160431](https://github.com/user-attachments/assets/f7f31edf-fc88-41ac-bf35-7513f955a401)
 
-Recorded tracks are private by default, so they are not shown to other users. You can decide to share a link to your track from the µlogger app.  
+Recorded tracks are private by default, so they are not shown to other users. You can decide to share a link to your track from the µlogger app.
 
 
 ## API endpoints
 Auth
 `curl -H 'Content-Type: application/x-www-form-urlencoded' -X POST http://localhost:3000/ulogger/client/index.php -d 'action=auth&pass=supers3cr3t&user=cwh@domain.org'`
 
-Sets a cookie with a token for the following requests. If a user with the provided email is found, the map is assigned to that user.
+Sets a cookie with a session token for the following requests. If a user with the provided email is found, the map is assigned to that user.
 
 New Track
 `curl -H 'Content-Type: application/x-www-form-urlencoded' -X POST http://localhost:3000/ulogger/client/index.php -d 'action=addtrack&track=Auto_2024.06.09_20.59.57'`
 
+By using a track name of format `<private_map_id>#<track_name>`, you can add your track to an existing map.
+
 Append New Trackpoint
 `curl -H 'Content-Type: application/x-www-form-urlencoded' -X POST http://localhost:3000/ulogger/client/index.php -d 'action=addpos&altitude=374.299987792969&provider=network&trackid=18&accuracy=16.113000869751&lon=11.1158342&time=1717959606&lat=49.4442029'`
 

engines/ulogger/app/controllers/api/ulogger_controller.rb

@@ -25,30 +25,53 @@ class Api::UloggerController < ApplicationController
       :stroke => "#62a0ea"
     }
 
+    # params: {"pass" => "pwd", "user" => "user@mail.com"}
     def auth
       session["email"] = params[:user]
       render json: { error: false }
     end
 
+    # Called by the app on first waypoint upload
+    # params: { "track" => "tom_2026-03-24_11.08" }
+    # When track name matches "<private_map_id>#<track name>", you can log into an existing map/track
     def addtrack
       @user = User.find_by(email: session["email"])
-      map_id, padded_id = create_numeric_map_id
-      @map = Map.create!(private_id: padded_id, name: params[:track],
-        public_id: params[:track],
-        view_permission: "link",
-        edit_permission: "link",
-        user: @user)
-      @map.save!
-      render json: { error: false, trackid: map_id }
+      if params[:track] =~ /^(\d+)#(\S+)/
+        session["track_name"] = $2
+        @map = Map.find_by(private_id: $1)
+      else
+        session["track_name"] = params[:track]
+        @map = Map.create!(private_id: random_map_id, name: params[:track],
+          view_permission: "link",
+          edit_permission: "link",
+          user: @user)
+      end
+      if @map
+        render json: { error: false, trackid:  @map.private_id.to_i }
+      else
+        Rails.logger.error("Cannot create map for track '#{params[:track]}'")
+        render json: { error: true, message: "Invalid trackid" }
+      end
     end
 
+    # params: {"altitude" => "384.600006103516", "provider" => "network",
+    #          "trackid" => "123", "accuracy" => "12.3999996185303",
+    #          "lon" => "11.0871855", "time" => "1774346910", "lat" => "49.428361"}
+    #
+    # Uses/Creates track with track name from 'addtrack' call before
     def addpos
       coords = [ params[:lon].to_f, params[:lat].to_f, params[:altitude].to_f.round(2) ]
-      features = @map.layers.geojson.first.features
 
-      # if the map has no track yet, create one, else append
-      track = features.line_string.first
-      track ||= Feature.new(layer: @map.layers.first, geometry: { "coordinates" => [] }, properties: TRACK_PROPERTIES)
+      # Find track layer, fallback to map name which also has the initial track name by default
+      track_name = session["track_name"] || @map.name
+      layer = @map.layers.geojson.find { |l| l.name == track_name } || @map.layers.create(name: track_name)
+      features = layer.features
+
+      # Find track with current name on map, or create new
+      track = features.line_string.find { |l| l.properties['title'] == track_name }
+      track ||= Feature.new(layer: layer, geometry: { "coordinates" => [] }, properties: TRACK_PROPERTIES)
+      track.update(properties: track.properties.merge({ 'title' => track_name }))
+
       track_coords = track.geometry["coordinates"] << coords
       track.update(geometry: { "type" => "LineString",
                               "coordinates" => track_coords })
@@ -96,7 +119,7 @@ def addpos
     private
 
     def set_map
-      @map = Map.find_by(private_id: "%024d" % [ params[:trackid] ])
+      @map = Map.find_by(private_id: params[:trackid])
       render json: { error: true, message: "Invalid trackid" } unless @map
     end
 
@@ -123,8 +146,8 @@ def image_properties(img)
 
     def location_properties
       { "marker-size": "8",
-       "marker-color": "#ff7800",
-       stroke: "#000000" }
+        "marker-color": "#ff7800",
+        "stroke": "#000000" }
     end
 
     def description
@@ -138,13 +161,9 @@ def description
       end.join("\n")
     end
 
-    # mongoid needs a BSON::ObjectId (24 char hex) as primary key,
-    # which we use as map id currently
-    def create_numeric_map_id
-      id = SecureRandom.rand(1..JAVA_MAXINT)
-      padded = "%024d" % [ id ]
-      return create_numeric_map_id if Map.exists?(private_id: padded)
-      [ id, padded ]
+    # ulogger needs a numeric map id
+    def random_map_id
+      SecureRandom.rand(1..JAVA_MAXINT)
     end
   end
 end

engines/ulogger/spec/requests/api/ulogger_controller_spec.rb

@@ -16,25 +16,44 @@
   describe "#addtrack" do
     subject { response }
 
-    before { post "/ulogger/client/index.php", params: payload }
-
-    let(:payload) { { action: "addtrack", track: "ulogger track" } }
     let(:response_body) { JSON.parse(response.body) }
 
-    it { is_expected.to have_http_status(200) }
-    it { expect(response_body["error"]).to be(false) }
+    context "creating a new track" do
+      before { post "/ulogger/client/index.php", params: payload }
 
-    it "returns a numeric id" do
-      expect(response_body["trackid"]).to be > 0
-      expect(response_body["trackid"]).to be < Api::UloggerController::JAVA_MAXINT
-    end
+      let(:payload) { { action: "addtrack", track: "ulogger track" } }
+
+      it { is_expected.to have_http_status(200) }
+      it { expect(response_body["error"]).to be(false) }
 
-    it "creates map in db with 24 digits" do
-      expect(Map.find_by(private_id: "%024d" % [ response_body["trackid"] ])).not_to be_nil
+      it "returns a numeric id" do
+        expect(response_body["trackid"]).to be > 0
+        expect(response_body["trackid"]).to be < Api::UloggerController::JAVA_MAXINT
+      end
+
+      it "creates map in db with trackid" do
+        expect(Map.find_by(private_id: response_body["trackid"])).not_to be_nil
+      end
+
+      it "sets map name" do
+        expect(Map.find_by(private_id: response_body["trackid"]).name).to eq "ulogger track"
+      end
     end
 
-    it "sets map name" do
-      expect(Map.find_by(private_id: "%024d" % [ response_body["trackid"] ]).name).to eq "ulogger track"
+    context "using existing map" do
+      before do
+         post "/ulogger/client/index.php", params: payload
+      end
+
+      let(:map) { create(:map, private_id: 12345) }
+      let(:payload) { { action: "addtrack", track: "#{map.private_id}#ulogger track2" } }
+
+      it { is_expected.to have_http_status(200) }
+      it { expect(response_body["error"]).to be(false) }
+
+      it "uses existing map" do
+        expect(response_body["trackid"]).to eq map.private_id.to_i
+      end
     end
   end
 
@@ -46,7 +65,7 @@
       post "/ulogger/client/index.php", params: payload
     end
 
-    let(:map) { create(:map, private_id: "%024d" % [ trackid ]) }
+    let(:map) { create(:map, private_id: trackid, name: 'ulogger') }
     let(:trackid) { 924977797 }
     let(:payload) {
       { action: "addpos", altitude: 374.29, speed: 4.3,
@@ -58,6 +77,17 @@
     it { is_expected.to have_http_status(200) }
     it { expect(response_body["error"]).to be(false) }
 
+    it "creates new layer for track" do
+      expect(map.reload.layers.count).to eq 2
+      # no session["track_name"] is set, track layer will inherit map name
+      expect(map.layers.geojson.select { |l| l.name == "ulogger" }.count).to eq 1
+    end
+
+    it "adds points into the new layer" do
+      layer = map.reload.layers.geojson.find { |l| l.name == "ulogger" }
+      expect(layer.features.point.count).to eq 1
+    end
+
     it "adds point feature at coordinates" do
       expect(map.reload.features.point.count).to eq 1
       expect(map.reload.features.point.first.geometry["coordinates"])