Event endpoint to handle notifications was implemented

src/main/java/org/prebid/server/analytics/model/NotificationEvent.java

@@ -0,0 +1,14 @@
+package org.prebid.server.analytics.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Value;
+
+@AllArgsConstructor(staticName = "of")
+@Value
+public class NotificationEvent {
+    String type;
+
+    String bidId;
+
+    String bidder;
+}

src/main/java/org/prebid/server/handler/NotificationEventHandler.java

@@ -0,0 +1,143 @@
+package org.prebid.server.handler;
+
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.HttpHeaders;
+import io.vertx.ext.web.RoutingContext;
+import lombok.AllArgsConstructor;
+import lombok.Value;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.prebid.server.analytics.AnalyticsReporter;
+import org.prebid.server.analytics.model.HttpContext;
+import org.prebid.server.analytics.model.NotificationEvent;
+import org.prebid.server.exception.InvalidRequestException;
+import org.prebid.server.util.ResourceUtil;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Accepts notifications from browsers and mobile application for further processing by {@link AnalyticsReporter}
+ * and responding with tracking pixel when requested.
+ */
+public class NotificationEventHandler implements Handler<RoutingContext> {
+
+    private static final String TRACKING_PIXEL_PNG = "static/tracking-pixel.png";
+    private static final String TRACKING_PIXEL_JPG = "static/tracking-pixel.jpg";
+    private static final String VIEW_TYPE = "view";
+    private static final String WIN_TYPE = "win";
+    private static final String FORMAT_PARAMETER = "format";
+    private static final String TYPE_PARAMETER = "type";
+    private static final String BID_ID_PARAMETER = "bidid";
+    private static final String BIDDER_PARAMETER = "bidder";
+    private static final String JPG_FORMAT = "jpg";
+    private static final String PNG_FORMAT = "png";
+    private static final String JPG_CONTENT_TYPE = "image/jpeg";
+    private static final String PNG_CONTENT_TYPE = "image/png";
+
+    private final AnalyticsReporter analyticsReporter;
+    private final Map<String, TrackingPixel> trackingPixels;
+
+    private NotificationEventHandler(AnalyticsReporter analyticsReporter, Map<String, TrackingPixel> trackingPixels) {
+        this.analyticsReporter = analyticsReporter;
+        this.trackingPixels = trackingPixels;
+    }
+
+    public static NotificationEventHandler create(AnalyticsReporter analyticsReporter) {
+        final Map<String, TrackingPixel> trackingPixels = new HashMap<>();
+        trackingPixels.put(JPG_FORMAT, TrackingPixel.of(JPG_CONTENT_TYPE, readTrackingPixel(TRACKING_PIXEL_JPG)));
+        trackingPixels.put(PNG_FORMAT, TrackingPixel.of(PNG_CONTENT_TYPE, readTrackingPixel(TRACKING_PIXEL_PNG)));
+        return new NotificationEventHandler(Objects.requireNonNull(analyticsReporter), trackingPixels);
+    }
+
+    @Override
+    public void handle(RoutingContext context) {
+        final MultiMap queryParameters = context.request().params();
+
+        final NotificationEvent notificationEvent;
+        try {
+            notificationEvent = makeNotificationEvent(queryParameters);
+        } catch (InvalidRequestException ex) {
+            respondWithBadStatus(context, ex.getMessage());
+            return;
+        }
+
+        analyticsReporter.processEvent(notificationEvent);
+
+        final Map<String, String> queryParams = HttpContext.from(context).getQueryParams();
+        final String format = queryParams.get(FORMAT_PARAMETER);
+
+        try {
+            validateEventRequestQueryParams(format);
+        } catch (InvalidRequestException ex) {
+            respondWithBadStatus(context, ex.getMessage());
+            return;
+        }
+
+        respondWithOkStatus(context, format);
+    }
+
+    private static byte[] readTrackingPixel(String path) {
+        try {
+            return ResourceUtil.readByteArrayFromClassPath(path);
+        } catch (IOException e) {
+            throw new IllegalArgumentException(String.format("Failed to load pixel image at %s", path), e);
+        }
+    }
+
+    private NotificationEvent makeNotificationEvent(MultiMap queryParameters) {
+        final String type = queryParameters.get(TYPE_PARAMETER);
+        if (ObjectUtils.notEqual(type, VIEW_TYPE) && ObjectUtils.notEqual(type, WIN_TYPE)) {
+            throw new InvalidRequestException(String.format(
+                    "Type is required query parameter. Possible values are win and view, but was %s", type));
+        }
+
+        final String bidId = queryParameters.get(BID_ID_PARAMETER);
+        if (StringUtils.isBlank(bidId)) {
+            throw new InvalidRequestException("bidid is required query parameter and can't be empty.");
+        }
+
+        final String bidder = queryParameters.get(BIDDER_PARAMETER);
+        if (StringUtils.isBlank(bidder)) {
+            throw new InvalidRequestException("bidder is required query parameter and can't be empty.");
+        }
+        return NotificationEvent.of(type, bidId, bidder);
+    }
+
+    private void validateEventRequestQueryParams(String format) {
+        if (format != null && ObjectUtils.notEqual(format, JPG_FORMAT) && ObjectUtils.notEqual(format, PNG_FORMAT)) {
+            throw new InvalidRequestException("format when defined should has value of png or jpg.");
+        }
+    }
+
+    private void respondWithBadStatus(RoutingContext context, String message) {
+        context.response().setStatusCode(HttpResponseStatus.BAD_REQUEST.code())
+                .end(String.format("Request is invalid: %s", message));
+    }
+
+    private void respondWithOkStatus(RoutingContext context, String format) {
+        if (format != null) {
+            final TrackingPixel trackingPixel = trackingPixels.get(format);
+            context.response()
+                    .putHeader(HttpHeaders.CONTENT_TYPE, trackingPixel.getContentType())
+                    .end(Buffer.buffer(trackingPixel.getContent()));
+        } else {
+            context.response().end();
+        }
+    }
+
+    /**
+     * Internal class for holding pixels content type to its value
+     */
+    @AllArgsConstructor(staticName = "of")
+    @Value
+    private static class TrackingPixel {
+        String contentType;
+        byte[] content;
+    }
+}

src/main/java/org/prebid/server/spring/config/WebConfiguration.java

@@ -33,6 +33,7 @@
 import org.prebid.server.handler.CurrencyRatesHandler;
 import org.prebid.server.handler.ExceptionHandler;
 import org.prebid.server.handler.NoCacheHandler;
+import org.prebid.server.handler.NotificationEventHandler;
 import org.prebid.server.handler.OptoutHandler;
 import org.prebid.server.handler.SettingsCacheNotificationHandler;
 import org.prebid.server.handler.SetuidHandler;
@@ -146,6 +147,7 @@ Router router(CookieHandler cookieHandler,
                   BidderParamHandler bidderParamHandler,
                   BiddersHandler biddersHandler,
                   BidderDetailsHandler bidderDetailsHandler,
+                  NotificationEventHandler notificationEventHandler,
                   StaticHandler staticHandler) {
 
         final Router router = Router.router(vertx);
@@ -164,6 +166,7 @@ Router router(CookieHandler cookieHandler,
         router.get("/bidders/params").handler(bidderParamHandler);
         router.get("/info/bidders").handler(biddersHandler);
         router.get("/info/bidders/:bidderName").handler(bidderDetailsHandler);
+        router.get("/event").handler(notificationEventHandler);
         router.get("/static/*").handler(staticHandler);
         router.get("/").handler(staticHandler); // serves index.html by default
 
@@ -307,6 +310,11 @@ BidderDetailsHandler bidderDetailsHandler(BidderCatalog bidderCatalog) {
         return new BidderDetailsHandler(bidderCatalog);
     }
 
+    @Bean
+    NotificationEventHandler eventNotificationHandler(CompositeAnalyticsReporter compositeAnalyticsReporter) {
+        return NotificationEventHandler.create(compositeAnalyticsReporter);
+    }
+
     @Bean
     StaticHandler staticHandler() {
         return StaticHandler.create("static").setCachingEnabled(false);

src/main/java/org/prebid/server/util/ResourceUtil.java

@@ -1,5 +1,7 @@
 package org.prebid.server.util;
 
+import org.apache.commons.compress.utils.IOUtils;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
@@ -30,4 +32,15 @@ public static String readFromClasspath(String path) throws IOException {
             return reader.lines().collect(Collectors.joining("\n"));
         }
     }
+
+    /**
+     * Reads files from classpath as array of bytes. Throws {@link IllegalArgumentException} if file was not found.
+     */
+    public static byte[] readByteArrayFromClassPath(String path) throws IOException {
+        final InputStream resourceAsStream = ResourceUtil.class.getClassLoader().getResourceAsStream(path);
+        if (resourceAsStream == null) {
+            throw new IllegalArgumentException(String.format("Could not find file at path: %s", path));
+        }
+        return IOUtils.toByteArray(resourceAsStream);
+    }
 }

src/test/java/org/prebid/server/ApplicationTest.java

@@ -36,6 +36,7 @@
 import org.prebid.server.proto.response.BidderUsersyncStatus;
 import org.prebid.server.proto.response.CookieSyncResponse;
 import org.prebid.server.proto.response.UsersyncInfo;
+import org.prebid.server.util.ResourceUtil;
 import org.skyscreamer.jsonassert.JSONAssert;
 import org.skyscreamer.jsonassert.JSONCompareMode;
 import org.springframework.boot.test.context.SpringBootTest;
@@ -47,8 +48,10 @@
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.Base64;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 
 import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
 import static com.github.tomakehurst.wiremock.client.WireMock.equalTo;
@@ -1694,6 +1697,22 @@ public void infoBidderDetailsShouldReturnMetadataForBidder() throws IOException
                 .body(Matchers.equalTo(jsonFrom("info-bidders/test-info-bidder-details-response.json")));
     }
 
+    @Test
+    public void eventHandlerShouldRespondWithJPGTrackingPixel() throws IOException {
+        given(spec)
+                .queryParam("type", "win")
+                .queryParam("bidid", "bidId")
+                .queryParam("bidder", "rubicon")
+                .queryParam("format", "jpg")
+                .get("/event")
+                .then()
+                .assertThat()
+                .statusCode(200)
+                .header("content-type", "image/jpeg")
+                .body(Matchers.equalTo(
+                        Buffer.buffer(ResourceUtil.readByteArrayFromClassPath("static/tracking-pixel.jpg")).toString()));
+    }
+
     @Test
     public void shouldAskExchangeWithUpdatedSettingsFromCache() throws IOException, JSONException {
         // given