RES-1995: map of groups (Laravel 10)

.gitignore

@@ -38,3 +38,6 @@ restarters-anonymised.sql
 /public/repair-data*.csv
 /uploads/*.jpg
 .mcp.json
+
+# PHPUnit coverage output, regenerated on every test run.
+tests/clover.xml

app/Http/Controllers/API/GroupController.php

@@ -257,6 +257,12 @@
      *                   type="object",
      *                   @OA\Property(property="id", type="integer", example=1),
      *                   @OA\Property(property="name", type="string", example="Group Name"),
+     *                   @OA\Property(property="lat", type="number", nullable=true, example=51.5),
+     *                   @OA\Property(property="lng", type="number", nullable=true, example=-0.12),
+     *                   @OA\Property(property="country", type="string", nullable=true, example="United Kingdom"),
+     *                   @OA\Property(property="network_ids", type="array", @OA\Items(type="integer")),
+     *                   @OA\Property(property="tag_ids", type="array", @OA\Items(type="integer")),
+     *                   @OA\Property(property="archived_at", type="string", format="date-time", nullable=true),
      *                )
      *             )
      *          )
@@ -269,20 +275,40 @@
             'includeArchived' => ['string', 'in:true,false'],
         ]);
 
-        // We only return the group id and name, for speed.
-        $query = Group::select('idgroups', 'name', 'archived_at');
+        // We only return a small number of attributes, for speed: this index
+        // drives the groups map (positions/tooltips) and the client-side
+        // name/country/network/tag filters, with full rows hydrated on demand
+        // via /groups/summary?ids=.
+        $query = Group::select('idgroups', 'name', 'latitude', 'longitude', 'country_code', 'archived_at');
 
         if (!$request->has('includeArchived') || $request->get('includeArchived') == 'false') {
             $query = $query->whereNull('archived_at');
         }
 
         $groups = $query->get();
+
+        // Two cheap lookups instead of per-group relation loads.
+        $networkIds = \DB::table('group_network')
+            ->whereIn('group_id', $groups->pluck('idgroups'))
+            ->get()
+            ->groupBy('group_id');
+        $tagIds = \DB::table('grouptags_groups')
+            ->whereIn('group', $groups->pluck('idgroups'))
+            ->get()
+            ->groupBy('group');
+
         $ret = [];
 
         foreach ($groups as $group) {
             $ret[] = [
                 'id' => $group->idgroups,
                 'name' => $group->name,
+                'lat' => $group->latitude !== null ? (float) $group->latitude : null,
+                'lng' => $group->longitude !== null ? (float) $group->longitude : null,
+                'country' => \App\Helpers\Fixometer::getCountryFromCountryCode($group->country_code),
+                'network_ids' => $networkIds->has($group->idgroups) ? $networkIds[$group->idgroups]->pluck('network_id')->map(fn ($id) => (int) $id)->all() : [],
+                // The pivot columns are varchars; the API contract is integers.
+                'tag_ids' => $tagIds->has($group->idgroups) ? $tagIds[$group->idgroups]->pluck('group_tag')->map(fn ($id) => (int) $id)->all() : [],
                 'archived_at' => $group->archived_at ? Carbon::parse($group->archived_at)->toIso8601String() : null
             ];
         }
@@ -292,6 +318,99 @@
         ];
     }
 
+    /**
+     * @OA\Get(
+     *      path="/api/v2/groups/summary",
+     *      operationId="getGroupSummariesv2",
+     *      tags={"Groups"},
+     *      summary="Get list of groups with summary information",
+     *      @OA\Parameter(
+     *          name="archived",
+     *          description="Include archived groups.  Default false.",
+     *          required=false,
+     *          in="query",
+     *          @OA\Schema(
+     *              type="boolean"
+     *          )
+     *      ),
+     *      @OA\Parameter(
+     *          name="includeNextEvent",
+     *          description="Include the next event for the group.  This makes the call slower.  Default false.",
+     *          required=false,
+     *          in="query",
+     *          @OA\Schema(
+     *              type="boolean"
+     *          )
+     *      ),
+     *      @OA\Parameter(
+     *          name="includeCounts",
+     *          description="Include the counts of hosts and restarters.  This makes the call slower.  Default false.",
+     *          required=false,
+     *          in="query",
+     *          @OA\Schema(
+     *              type="boolean"
+     *          )
+     *      ),
+     *      @OA\Parameter(
+     *          name="ids",
+     *          description="Comma-separated group ids.  When present, only these groups are returned (used by the groups list to hydrate the visible rows).  Maximum 200 ids.",
+     *          required=false,
+     *          in="query",
+     *          @OA\Schema(
+     *              type="string"
+     *          )
+     *      ),
+     *      @OA\Response(
+     *          response=200,
+     *          description="Successful operation",
+     *          @OA\JsonContent(
+     *              @OA\Property(
+     *                property="data",
+     *                title="data",
+     *                description="An array of events",
+     *                type="array",
+     *                @OA\Items(
+     *                    @OA\Schema(
+     *                       ref="#/components/schemas/GroupSummary"
+     *                    ),
+     *                 )
+     *              )
+     *          )
+     *       ),
+     *     )
+     */
+
+    public static function listSummaryv2(Request $request) {
+        $request->validate([
+            'archived' => ['string', 'in:true,false'],
+            'ids' => ['string', 'regex:/^\d+(,\d+)*$/', function ($attribute, $value, $fail) {
+                if (count(explode(',', $value)) > 200) {
+                    $fail('A maximum of 200 ids may be requested at once.');
+                }
+            }],
+        ]);
+
+        // Eager-load everything the GroupSummary resource touches, otherwise
+        // each group lazy-loads its relations and the call scales O(N).
+        $query = Group::with(['networks', 'groupImage.image', 'group_tags']);
+
+        if ($request->get('archived', 'false') !== 'true') {
+            $query = $query->whereNull('archived_at');
+        }
+
+        // The groups list hydrates just its visible rows this way, instead of
+        // paying to serialise every group on page load.
+        if ($request->filled('ids')) {
+            $query = $query->whereIn('idgroups', explode(',', $request->get('ids')));
+        }
+
+        $groups = $query->get();
+
+        return [
+            'data' => \App\Http\Resources\GroupSummaryCollection::make($groups)
+        ];
+    }
+
     /**
      * @OA\Get(
      *      path="/api/v2/groups/tags",

app/Http/Controllers/GroupController.php

@@ -32,15 +32,13 @@
 use FixometerFile;
 use Illuminate\Database\QueryException;
 use Illuminate\Http\Request;
-use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\Log;
 use Notification;
 use Spatie\ValidationRules\Rules\Delimited;
-use Carbon\Carbon;
 
 class GroupController extends Controller
 {
     private function indexVariations($tab, $network)
     {
         //Get current logged in user
         $user = Auth::user();
@@ -60,11 +58,10 @@
         } else {
             $all_group_tags = collect([]);
         }
-        $networks = Network::all();
 
         // Look for groups we have joined, not just been invited to.  We have to explicitly test on deleted_at because
         // the normal filtering out of soft deletes won't happen for joins.
-        $your_groups =array_column(Group::with(['networks'])
+        $your_groups = array_column(Group::with(['networks'])
             ->join('users_groups', 'users_groups.group', '=', 'groups.idgroups')
             ->leftJoin('events', 'events.group', '=', 'groups.idgroups')
             ->where('users_groups.user', $user->id)
@@ -75,15 +72,54 @@
             ->get()
             ->toArray(), 'idgroups');
 
-        // We pass a high limit to the groups nearby; there is a distance limit which will normally kick in first.
-        $groups_near_you = array_column($user->groupsNearby(1000), 'idgroups');
+        $nearby_groups = [];
+        $min_lat = 90;
+        $max_lat = -90;
+        $min_lng = 180;
+        $max_lng = -180;
+
+        if ($user->latitude || $user->longitude || $user->country_code) {
+            // We pass a high limit to the groups nearby; there is a distance limit which will normally kick in first.
+            $nearby_groups = $user->groupsNearby(1000);
+
+            if (empty($nearby_groups) && $user->country_code) {
+                // groupsNearby() needs coordinates, which a user who has only set their country doesn't have.  We
+                // can still open the map on something better than the whole world by framing the groups in their
+                // country.  If there aren't any then we leave the bounding box alone, which the map reads as "no
+                // location" and falls back to showing every group.
+                $nearby_groups = Group::whereNull('archived_at')
+                    ->where('approved', true)
+                    ->where('country_code', $user->country_code)
+                    ->whereNotNull('latitude')
+                    ->whereNotNull('longitude')
+                    ->get();
+            }
+
+            // Now find the lat/lng bounding box which contains these groups.
+            foreach ($nearby_groups as $group) {
+                if ($group->latitude < $min_lat) {
+                    $min_lat = $group->latitude;
+                }
+                if ($group->latitude > $max_lat) {
+                    $max_lat = $group->latitude;
+                }
+                if ($group->longitude < $min_lng) {
+                    $min_lng = $group->longitude;
+                }
+                if ($group->longitude > $max_lng) {
+                    $max_lng = $group->longitude;
+                }
+            }
+        }
 
         return view('group.index', [
-            'groups' => GroupController::expandGroups($groups, $your_groups, $groups_near_you),
+            'your_groups' => $your_groups,
+            'nearby_groups' => [ [ $min_lat, $min_lng ], [ $max_lat, $max_lng ] ],
             'your_area' => $user->location,
-            'tab' => $tab,
+            'your_lat' => $user->latitude,
+            'your_lng' => $user->longitude,
+            'tab' => (!$tab || $tab === 'mine') ? 'mine' : 'other',
             'network' => $network,
-            'networks' => $networks,
             'all_group_tags' => $all_group_tags,
         ]);
     }
@@ -105,7 +141,9 @@
 
     public function network($id)
     {
-        return $this->indexVariations('all', $id);
+        // Retired: network coordinators now see their groups on the network
+        // page itself (map + list). Kept as a redirect for old links.
+        return redirect('/networks/' . $id);
     }
 
     public function create(Request $request)
@@ -481,68 +519,6 @@
         }
     }
 
-    public static function expandGroups($groups, $your_groupids, $nearby_groupids)
-    {
-        $ret = [];
-        $user = Auth::user();
-
-        if ($groups) {
-            foreach ($groups as $group) {
-                $group_image = $group->groupImage;
-
-                $event = $group->nextUpcomingParty;
-
-                // We want to return the distance from our own location.
-                $distance = null;
-                $grouplat = $group->latitude;
-                $grouplng = $group->longitude;
-                $userlat = $user->latitude;
-                $userlng = $user->longitude;
-
-                if ($grouplat !== null && $grouplng !== null && $userlat !== null && $userlng !== null) {
-                    if ($grouplat == $userlat && $grouplng == $userlng) {
-                        $distance = 0;
-                    } else {
-                        $distance = 6371 * acos( cos(deg2rad($userlat)) * cos(deg2rad($grouplat)) * cos(deg2rad($grouplng) -
-                                                                                                        deg2rad($userlng)) + sin(deg2rad($userlat) ) * sin(deg2rad($grouplat)));
-                    }
-                }
-
-                $ret[] = [
-                    'idgroups' => $group->idgroups,
-                    'name' => $group->name,
-                    'image' => (is_object($group_image) && is_object($group_image->image)) ?
-                        asset('uploads/mid_'.$group_image->image->path) : null,
-                    'location' => [
-                        'location' => rtrim($group->location),
-                        'country' => Fixometer::getCountryFromCountryCode($group->country_code),
-                        'country_code' => $group->country_code,
-                        'distance' => $distance,
-                    ],
-                    'next_event' => $event ? $event->event_date_local : null,
-                    'all_restarters_count' => $group->all_restarters_count,
-                    'all_hosts_count' => $group->all_hosts_count,
-                    'all_confirmed_restarters_count' => $group->all_confirmed_restarters_count,
-                    'all_confirmed_hosts_count' => $group->all_confirmed_hosts_count,
-                    'networks' => \Illuminate\Support\Arr::pluck($group->networks, 'id'),
-                    'group_tags' => $group->group_tags->pluck('id'),
-                    'group_tags_full' => $group->group_tags->map(function($tag) {
-                        return [
-                            'id' => $tag->id,
-                            'name' => $tag->tag_name,
-                            'network_id' => $tag->network_id,
-                        ];
-                    }),
-                    'following' => in_array($group->idgroups, $your_groupids),
-                    'nearby' => in_array($group->idgroups, $nearby_groupids),
-                    'archived_at' => $group->archived_at ? Carbon::parse($group->archived_at)->toIso8601String() : null
-                ];
-            }
-        }
-
-        return $ret;
-    }
-
     public static function stats($id, $format = 'row')
     {
         $group = Group::where('idgroups', $id)->first();