Issue311 improve hook searching

gateleen-hook/README_hook.md

@@ -240,10 +240,43 @@ hookHandler.enableResourceLogging(true);
 ```
 
 
+## Query-Based Listener and Route Search
 
+Gateleen allows searching for listeners and routes using the query parameter `q`. This simplifies filtering the registered hooks based on query parameters.
 
+### Listener Search with `q`
+Search for listeners based on a query parameter like this:
 
+```
+GET http://myserver:7012/gateleen/server/listenertest/_hooks/listeners/listener/1?q=testQuery
+```
+
+The response will contain the matching listeners. If no match is found, an empty list is returned:
+
+**Example response with matches:**
+```json
+{
+  "listeners": [
+    {
+      "destination": "/path/to/destination",
+      "methods": ["GET", "POST"]
+    }
+  ]
+}
+```
 
+**Example response with no matches:**
+```json
+{
+  "listeners": []
+}
+```
 
+### Route Search with `q`
+Similarly, you can search for routes using a query parameter:
 
+```
+GET http://myserver:7012/gateleen/server/listenertest/_hooks/routes?q=testRoute
+```
 
+The response contains the matching routes, or an empty list if no match is found.

gateleen-hook/src/main/java/org/swisspush/gateleen/hook/HookHandler.java

@@ -70,6 +70,7 @@
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -123,6 +124,13 @@ public class HookHandler implements LoggableResource {
     public static final String LISTABLE = "listable";
     public static final String COLLECTION = "collection";
 
+    private static final String CONTENT_TYPE_JSON = "application/json";
+    private static final String LISTENERS_KEY = "listeners";
+    private static final String ROUTES_KEY = "routes";
+    private static final String DESTINATION_KEY = "destination";
+    private static final String CONTENT_TYPE_HEADER = "content-type";
+
+
     private final Comparator<String> collectionContentComparator;
     private static final Logger log = LoggerFactory.getLogger(HookHandler.class);
 
@@ -569,6 +577,22 @@ public boolean handle(final RoutingContext ctx) {
             }
         }
 
+        // 1. Check if the request method is GET
+        if (request.method() == HttpMethod.GET) {
+            String uri = request.uri();
+            String queryParam = request.getParam("q");
+            // 2. Check if the URI is for listeners or routes and has a query parameter
+            if (queryParam != null && !queryParam.isEmpty()) {
+                if (uri.contains(LISTENERS_KEY)) {
+                    handleListenerSearch(queryParam, request.response());
+                    return true;
+                } else if (uri.contains(ROUTES_KEY)) {
+                    handleRouteSearch(queryParam, request.response());
+                    return true;
+                }
+            }
+        }
+
         /*
          * 2) Check if we have to queue a request for listeners
          */
@@ -592,6 +616,65 @@ public boolean handle(final RoutingContext ctx) {
         }
     }
 
+    private void handleListenerSearch(String queryParam, HttpServerResponse response) {
+        handleSearch(
+                listenerRepository.getListeners().stream().collect(Collectors.toMap(Listener::getListenerId, listener -> listener)),
+                listener -> listener.getHook().getDestination(),
+                queryParam,
+                LISTENERS_KEY,
+                response
+        );
+    }
+
+    private void handleRouteSearch(String queryParam, HttpServerResponse response) {
+        handleSearch(
+                routeRepository.getRoutes(),
+                route -> route.getHook().getDestination(),
+                queryParam,
+                ROUTES_KEY,
+                response
+        );
+    }
+
+    /**
+     * Search the repository for items matching the query parameter.
+     * Returns a JSON response with the matched results.
+     * If any essential parameter (repository, response, getDestination) is null,
+     * a 400 Bad Request is returned.
+     *
+     * @param repository The items to search.
+     * @param getDestination Function to extract destinations.
+     * @param queryParam The query string to match.
+     * @param resultKey The key for the result in the response.
+     * @param response The HTTP response to return the results. Must not be null.
+     */
+    private <T> void handleSearch(Map<String, T> repository, Function<T, String> getDestination, String queryParam, String resultKey, HttpServerResponse response) {
+        if (repository == null || getDestination == null) {
+            response.setStatusCode(400).end(); // Bad request for missing parameters
+            return;
+        }
+
+        JsonArray matchingResults = new JsonArray();
+
+        repository.forEach((key, value) -> {
+            String destination = getDestination.apply(value);
+            if (destination != null && destination.contains(queryParam != null ? queryParam : "")) {
+                matchingResults.add(key);
+            }
+        });
+
+        JsonObject result = new JsonObject();
+        result.put(resultKey, matchingResults);
+
+        String encodedResult = result.encode();
+
+        response.putHeader(CONTENT_TYPE_HEADER, CONTENT_TYPE_JSON);
+        response.putHeader("Content-Length", String.valueOf(encodedResult.length()));
+        response.write(encodedResult);
+        response.end();
+    }
+
+
     /**
      * Create a listing of routes in the given parent. This happens
      * only if we have a GET request, the routes are listable and