map bounds fix

lib/aprs/release.ex

@@ -6,9 +6,9 @@ defmodule Aprs.Release do
   @app :aprs
 
   def migrate do
+    require Logger
     # Initialize deployment timestamp first
     deployed_at = init()
-    require Logger
     Logger.info("Deployment timestamp: #{deployed_at}")
 
     # Run migrations
@@ -20,10 +20,6 @@ defmodule Aprs.Release do
     {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version))
   end
 
-  defp repos do
-    Application.fetch_env!(@app, :ecto_repos)
-  end
-
   defp load_app do
     Application.load(@app)
   end

lib/aprs_web/live/map_live/index.ex

@@ -143,18 +143,14 @@ defmodule AprsWeb.MapLive.Index do
 
   @impl true
   def handle_event("bounds_changed", %{"bounds" => bounds}, socket) do
-    Logger.debug(
+    Logger.debug("handle_event bounds_changed: #{inspect(bounds)} vs current #{inspect(socket.assigns.map_bounds)}")
-      "handle_event bounds_changed: #{inspect(bounds)} vs current #{inspect(socket.assigns.map_bounds)}"
-    )
 
     handle_bounds_update(bounds, socket)
   end
 
   @impl true
   def handle_event("update_bounds", %{"bounds" => bounds}, socket) do
-    Logger.debug(
+    Logger.debug("handle_event update_bounds: #{inspect(bounds)} vs current #{inspect(socket.assigns.map_bounds)}")
-      "handle_event update_bounds: #{inspect(bounds)} vs current #{inspect(socket.assigns.map_bounds)}"
-    )
 
     handle_bounds_update(bounds, socket)
   end
@@ -318,9 +314,7 @@ defmodule AprsWeb.MapLive.Index do
       west: bounds["west"]
     }
 
-    Logger.debug(
+    Logger.debug("handle_bounds_update: new #{inspect(map_bounds)} vs current #{inspect(socket.assigns.map_bounds)}")
-      "handle_bounds_update: new #{inspect(map_bounds)} vs current #{inspect(socket.assigns.map_bounds)}"
-    )
 
     # Validate bounds to prevent invalid coordinates
     if map_bounds.north > 90 or map_bounds.south < -90 or
@@ -346,9 +340,7 @@ defmodule AprsWeb.MapLive.Index do
 
   @spec process_bounds_update(map(), Socket.t()) :: Socket.t()
   defp process_bounds_update(map_bounds, socket) do
-    Logger.debug(
+    Logger.debug("process_bounds_update: Loading historical packets for bounds #{inspect(map_bounds)}")
-      "process_bounds_update: Loading historical packets for bounds #{inspect(map_bounds)}"
-    )
 
     # Remove out-of-bounds packets and markers immediately
     new_visible_packets =
@@ -382,30 +374,22 @@ defmodule AprsWeb.MapLive.Index do
   end
 
   @impl true
-  def handle_info({:process_bounds_update, map_bounds}, socket),
+  def handle_info({:process_bounds_update, map_bounds}, socket), do: handle_info_process_bounds_update(map_bounds, socket)
-    do: handle_info_process_bounds_update(map_bounds, socket)
 
-  def handle_info({:delayed_zoom, %{lat: lat, lng: lng}}, socket),
+  def handle_info({:delayed_zoom, %{lat: lat, lng: lng}}, socket), do: handle_info_delayed_zoom(lat, lng, socket)
-    do: handle_info_delayed_zoom(lat, lng, socket)
 
-  def handle_info({:ip_location, %{lat: lat, lng: lng}}, socket),
+  def handle_info({:ip_location, %{lat: lat, lng: lng}}, socket), do: handle_info_ip_location(lat, lng, socket)
-    do: handle_info_ip_location(lat, lng, socket)
 
   def handle_info(:initialize_replay, socket), do: handle_info_initialize_replay(socket)
 
   def handle_info(:cleanup_old_packets, socket), do: handle_cleanup_old_packets(socket)
 
-  def handle_info(:reload_historical_packets, socket),
+  def handle_info(:reload_historical_packets, socket), do: handle_reload_historical_packets(socket)
-    do: handle_reload_historical_packets(socket)
 
-  def handle_info({:postgres_packet, packet}, socket),
+  def handle_info({:postgres_packet, packet}, socket), do: handle_info_postgres_packet(packet, socket)
-    do: handle_info_postgres_packet(packet, socket)
 
-  def handle_info(
+  def handle_info(%Phoenix.Socket.Broadcast{topic: "aprs_messages", event: "packet", payload: packet}, socket),
-        %Phoenix.Socket.Broadcast{topic: "aprs_messages", event: "packet", payload: packet},
+    do: handle_info({:postgres_packet, packet}, socket)
-        socket
-      ),
-      do: handle_info({:postgres_packet, packet}, socket)
 
   # Private handler functions for each message type
 

lib/aprs_web/live/map_live/map_helpers.ex

@@ -52,67 +52,72 @@ defmodule AprsWeb.MapLive.MapHelpers do
 
   @spec within_bounds?(map() | tuple(), map()) :: boolean()
   def within_bounds?(packet_or_coords, bounds) do
-    to_float = fn
+    # Handle nil bounds
-      n when is_float(n) ->
+    if is_nil(bounds) do
-        n
-
-      n when is_integer(n) ->
-        n * 1.0
-
-      %Decimal{} = d ->
-        Decimal.to_float(d)
-
-      n when is_binary(n) ->
-        case Float.parse(n) do
-          {f, _} -> f
-          :error -> 0.0
-        end
-
-      _ ->
-        0.0
-    end
-
-    {lat, lon} =
-      cond do
-        is_map(packet_or_coords) and Map.has_key?(packet_or_coords, :lat) and
-            Map.has_key?(packet_or_coords, :lon) ->
-          {packet_or_coords.lat, packet_or_coords.lon}
-
-        is_map(packet_or_coords) and Map.has_key?(packet_or_coords, "lat") and
-            Map.has_key?(packet_or_coords, "lon") ->
-          {packet_or_coords["lat"], packet_or_coords["lon"]}
-
-        is_map(packet_or_coords) and Map.has_key?(packet_or_coords, :latitude) and
-            Map.has_key?(packet_or_coords, :longitude) ->
-          {packet_or_coords.latitude, packet_or_coords.longitude}
-
-        is_tuple(packet_or_coords) and tuple_size(packet_or_coords) == 2 ->
-          packet_or_coords
-
-        true ->
-          {nil, nil}
-      end
-
-    if is_nil(lat) or is_nil(lon) do
       false
     else
-      lat = to_float.(lat)
+      to_float = fn
-      lon = to_float.(lon)
+        n when is_float(n) ->
-      south = to_float.(bounds.south)
+          n
-      north = to_float.(bounds.north)
-      west = to_float.(bounds.west)
-      east = to_float.(bounds.east)
 
-      lat_in_bounds = lat >= south && lat <= north
+        n when is_integer(n) ->
+          n * 1.0
 
-      lng_in_bounds =
+        %Decimal{} = d ->
-        if west <= east do
+          Decimal.to_float(d)
-          lon >= west && lon <= east
+
-        else
+        n when is_binary(n) ->
-          lon >= west || lon <= east
+          case Float.parse(n) do
+            {f, _} -> f
+            :error -> 0.0
+          end
+
+        _ ->
+          0.0
+      end
+
+      {lat, lon} =
+        cond do
+          is_map(packet_or_coords) and Map.has_key?(packet_or_coords, :lat) and
+              Map.has_key?(packet_or_coords, :lon) ->
+            {packet_or_coords.lat, packet_or_coords.lon}
+
+          is_map(packet_or_coords) and Map.has_key?(packet_or_coords, "lat") and
+              Map.has_key?(packet_or_coords, "lon") ->
+            {packet_or_coords["lat"], packet_or_coords["lon"]}
+
+          is_map(packet_or_coords) and Map.has_key?(packet_or_coords, :latitude) and
+              Map.has_key?(packet_or_coords, :longitude) ->
+            {packet_or_coords.latitude, packet_or_coords.longitude}
+
+          is_tuple(packet_or_coords) and tuple_size(packet_or_coords) == 2 ->
+            packet_or_coords
+
+          true ->
+            {nil, nil}
         end
 
-      lat_in_bounds && lng_in_bounds
+      if is_nil(lat) or is_nil(lon) do
+        false
+      else
+        lat = to_float.(lat)
+        lon = to_float.(lon)
+        south = to_float.(bounds.south)
+        north = to_float.(bounds.north)
+        west = to_float.(bounds.west)
+        east = to_float.(bounds.east)
+
+        lat_in_bounds = lat >= south && lat <= north
+
+        lng_in_bounds =
+          if west <= east do
+            lon >= west && lon <= east
+          else
+            lon >= west || lon <= east
+          end
+
+        lat_in_bounds && lng_in_bounds
+      end
     end
   end
 end