Multiple Bidder Codes

extra/modules/ortb2-blocking/src/main/java/org/prebid/server/hooks/modules/ortb2/blocking/v1/Ortb2BlockingBidderRequestHook.java

@@ -2,7 +2,7 @@
 
 import com.iab.openrtb.request.BidRequest;
 import io.vertx.core.Future;
-import org.prebid.server.auction.BidderAliases;
+import org.prebid.server.auction.aliases.BidderAliases;
 import org.prebid.server.auction.versionconverter.OrtbVersion;
 import org.prebid.server.bidder.BidderCatalog;
 import org.prebid.server.hooks.execution.v1.InvocationResultImpl;

src/main/java/org/prebid/server/analytics/reporter/greenbids/GreenbidsAnalyticsReporter.java

@@ -383,7 +383,7 @@ private static Map<String, NonBid> getSeatsWithNonBids(AuctionContext auctionCon
 
     private static SeatNonBid toSeatNonBid(String bidder, BidRejectionTracker bidRejectionTracker) {
         final List<NonBid> nonBids = bidRejectionTracker.getRejectedImps().entrySet().stream()
-                .map(entry -> NonBid.of(entry.getKey(), entry.getValue()))
+                .map(entry -> NonBid.of(entry.getKey(), entry.getValue().getRight()))
                 .toList();
 
         return SeatNonBid.of(bidder, nonBids);

src/main/java/org/prebid/server/auction/BidsAdjuster.java

@@ -2,6 +2,7 @@
 
 import com.iab.openrtb.request.BidRequest;
 import com.iab.openrtb.response.Bid;
+import org.prebid.server.auction.aliases.BidderAliases;
 import org.prebid.server.auction.model.AuctionContext;
 import org.prebid.server.auction.model.AuctionParticipation;
 import org.prebid.server.auction.model.BidderResponse;
@@ -44,7 +45,6 @@ public List<AuctionParticipation> validateAndAdjustBids(List<AuctionParticipatio
 
         return auctionParticipations.stream()
                 .map(auctionParticipation -> validBidderResponse(auctionParticipation, auctionContext, aliases))
-
                 .map(auctionParticipation -> bidAdjustmentsProcessor.enrichWithAdjustedBids(
                         auctionParticipation,
                         auctionContext.getBidRequest(),

src/main/java/org/prebid/server/auction/ExchangeService.java

@@ -28,6 +28,8 @@
 import org.prebid.server.activity.infrastructure.payload.ActivityInvocationPayload;
 import org.prebid.server.activity.infrastructure.payload.impl.ActivityInvocationPayloadImpl;
 import org.prebid.server.activity.infrastructure.payload.impl.BidRequestActivityInvocationPayload;
+import org.prebid.server.auction.aliases.AlternateBidderCodesConfig;
+import org.prebid.server.auction.aliases.BidderAliases;
 import org.prebid.server.auction.mediatypeprocessor.MediaTypeProcessingResult;
 import org.prebid.server.auction.mediatypeprocessor.MediaTypeProcessor;
 import org.prebid.server.auction.model.AuctionContext;
@@ -79,6 +81,7 @@
 import org.prebid.server.proto.openrtb.ext.request.ExtDooh;
 import org.prebid.server.proto.openrtb.ext.request.ExtRequest;
 import org.prebid.server.proto.openrtb.ext.request.ExtRequestPrebid;
+import org.prebid.server.proto.openrtb.ext.request.ExtRequestPrebidAlternateBidderCodes;
 import org.prebid.server.proto.openrtb.ext.request.ExtRequestPrebidBidderConfig;
 import org.prebid.server.proto.openrtb.ext.request.ExtRequestPrebidCache;
 import org.prebid.server.proto.openrtb.ext.request.ExtRequestPrebidData;
@@ -88,6 +91,7 @@
 import org.prebid.server.proto.openrtb.ext.request.ExtRequestTargeting;
 import org.prebid.server.proto.openrtb.ext.request.ExtSite;
 import org.prebid.server.proto.openrtb.ext.request.ExtUser;
+import org.prebid.server.proto.openrtb.ext.response.ExtBidPrebidMeta;
 import org.prebid.server.settings.model.Account;
 import org.prebid.server.util.HttpUtil;
 import org.prebid.server.util.ListUtil;
@@ -115,6 +119,7 @@ public class ExchangeService {
     private static final ConditionalLogger conditionalLogger = new ConditionalLogger(logger);
 
     private static final String PREBID_EXT = "prebid";
+    private static final String PREBID_META_EXT = "meta";
     private static final String BIDDER_EXT = "bidder";
     private static final String TID_EXT = "tid";
     private static final String ALL_BIDDERS_CONFIG = "*";
@@ -233,7 +238,7 @@ private Future<AuctionContext> runAuction(AuctionContext receivedContext) {
         final MetricName requestTypeMetric = receivedContext.getRequestTypeMetric();
 
         final List<SeatBid> storedAuctionResponses = new ArrayList<>();
-        final BidderAliases aliases = aliases(bidRequest);
+        final BidderAliases aliases = aliases(bidRequest, account);
         final BidRequestCacheInfo cacheInfo = bidRequestCacheInfo(bidRequest);
         final Map<String, MultiBidConfig> bidderToMultiBid = bidderToMultiBids(bidRequest, debugWarnings);
         receivedContext.getBidRejectionTrackers().putAll(makeBidRejectionTrackers(bidRequest, aliases));
@@ -273,7 +278,7 @@ private Future<AuctionContext> runAuction(AuctionContext receivedContext) {
                         .map(auctionParticipations -> updateResponsesMetrics(auctionParticipations, account, aliases))
                         .map(context::with))
                 // produce response from bidder results
-                .compose(context -> bidResponseCreator.create(context, cacheInfo, aliases, bidderToMultiBid)
+                .compose(context -> bidResponseCreator.create(context, cacheInfo, bidderToMultiBid)
                         .map(bidResponse -> criteriaLogManager.traceResponse(
                                 logger,
                                 bidResponse,
@@ -284,11 +289,19 @@ private Future<AuctionContext> runAuction(AuctionContext receivedContext) {
                         .map(context::with));
     }
 
-    private BidderAliases aliases(BidRequest bidRequest) {
+    private BidderAliases aliases(BidRequest bidRequest, Account account) {
         final ExtRequestPrebid prebid = PbsUtil.extRequestPrebid(bidRequest);
         final Map<String, String> aliases = prebid != null ? prebid.getAliases() : null;
         final Map<String, Integer> aliasgvlids = prebid != null ? prebid.getAliasgvlids() : null;
-        return BidderAliases.of(aliases, aliasgvlids, bidderCatalog);
+        final ExtRequestPrebidAlternateBidderCodes alternateBidderCodes = prebid != null
+                ? prebid.getAlternateBidderCodes()
+                : null;
+
+        final AlternateBidderCodesConfig alternateBidderCodesConfig = ObjectUtils.defaultIfNull(
+                alternateBidderCodes,
+                account.getAlternateBidderCodes());
+
+        return BidderAliases.of(aliases, aliasgvlids, bidderCatalog, alternateBidderCodesConfig);
     }
 
     private static ExtRequestTargeting targeting(BidRequest bidRequest) {
@@ -1225,9 +1238,43 @@ private Future<BidderResponse> requestBids(BidderRequest bidderRequest,
                         requestHeaders,
                         aliases,
                         debugResolver.resolveDebugForBidder(auctionContext, resolvedBidderName)))
+                .map(seatBid -> populateBidderCode(seatBid, bidderName, resolvedBidderName))
                 .map(seatBid -> BidderResponse.of(bidderName, seatBid, responseTime(bidderRequestStartTime)));
     }
 
+    private BidderSeatBid populateBidderCode(BidderSeatBid seatBid, String bidderName, String resolvedBidderName) {
+        return seatBid.with(seatBid.getBids().stream()
+                .map(bidderBid -> bidderBid.toBuilder()
+                        .seat(ObjectUtils.defaultIfNull(bidderBid.getSeat(), bidderName))
+                        .bid(bidderBid.getBid().toBuilder()
+                                .ext(prepareBidExt(
+                                        bidderBid.getBid().getExt(),
+                                        bidderCatalog.configuredName(resolvedBidderName)))
+                                .build())
+                        .build())
+                .toList());
+    }
+
+    private ObjectNode prepareBidExt(ObjectNode bidExt, String bidderName) {
+        final ObjectNode updatedBidExt = bidExt != null ? bidExt : mapper.mapper().createObjectNode();
+
+        final ObjectNode extPrebid = objectNodeFromOrNew(updatedBidExt, PREBID_EXT);
+        final ObjectNode extPrebidMeta = objectNodeFromOrNew(extPrebid, PREBID_META_EXT);
+
+        final ObjectNode newData = mapper.mapper().valueToTree(
+                ExtBidPrebidMeta.builder().adapterCode(bidderName).build());
+        extPrebidMeta.setAll(newData);
+
+        return updatedBidExt;
+    }
+
+    private ObjectNode objectNodeFromOrNew(ObjectNode parent, String key) {
+        final JsonNode childNode = parent.get(key);
+        return childNode == null || !childNode.isObject()
+                ? parent.putObject(key)
+                : (ObjectNode) childNode;
+    }
+
     private BidRequest adjustTmax(BidRequest bidRequest,
                                   long startTime,
                                   int adjustmentFactor,

src/main/java/org/prebid/server/auction/ImpAdjuster.java

@@ -4,6 +4,7 @@
 import com.fasterxml.jackson.databind.node.IntNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.iab.openrtb.request.Imp;
+import org.prebid.server.auction.aliases.BidderAliases;
 import org.prebid.server.json.JacksonMapper;
 import org.prebid.server.json.JsonMerger;
 import org.prebid.server.validation.ImpValidator;

src/main/java/org/prebid/server/auction/SkippedAuctionService.java

@@ -1,33 +1,35 @@
 package org.prebid.server.auction;
 
 import com.iab.openrtb.request.BidRequest;
+import com.iab.openrtb.response.BidResponse;
 import com.iab.openrtb.response.SeatBid;
 import io.vertx.core.Future;
 import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.ListUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.prebid.server.auction.model.AuctionContext;
 import org.prebid.server.auction.model.StoredResponseResult;
+import org.prebid.server.bidder.model.BidderError;
 import org.prebid.server.exception.InvalidRequestException;
 import org.prebid.server.execution.timeout.Timeout;
 import org.prebid.server.proto.openrtb.ext.request.ExtRequest;
 import org.prebid.server.proto.openrtb.ext.request.ExtRequestPrebid;
 import org.prebid.server.proto.openrtb.ext.request.ExtStoredAuctionResponse;
+import org.prebid.server.proto.openrtb.ext.response.ExtBidResponse;
+import org.prebid.server.proto.openrtb.ext.response.ExtBidderError;
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 
 public class SkippedAuctionService {
 
     private final StoredResponseProcessor storedResponseProcessor;
-    private final BidResponseCreator bidResponseCreator;
-
-    public SkippedAuctionService(StoredResponseProcessor storedResponseProcessor,
-                                 BidResponseCreator bidResponseCreator) {
 
+    public SkippedAuctionService(StoredResponseProcessor storedResponseProcessor) {
         this.storedResponseProcessor = Objects.requireNonNull(storedResponseProcessor);
-        this.bidResponseCreator = Objects.requireNonNull(bidResponseCreator);
     }
 
     public Future<AuctionContext> skipAuction(AuctionContext auctionContext) {
@@ -53,7 +55,7 @@ public Future<AuctionContext> skipAuction(AuctionContext auctionContext) {
                         auctionContext.getDebugWarnings().add(throwable.getMessage());
                         return Future.succeededFuture(Collections.emptyList());
                     })
-                    .compose(storedSeatBids -> enrichAuctionContextWithBidResponse(auctionContext, storedSeatBids))
+                    .map(storedSeatBids -> enrichAuctionContextWithBidResponse(auctionContext, storedSeatBids))
                     .map(AuctionContext::skipAuction);
         }
 
@@ -65,7 +67,7 @@ public Future<AuctionContext> skipAuction(AuctionContext auctionContext) {
                         auctionContext.getDebugWarnings().add(throwable.getMessage());
                         return Future.succeededFuture(Collections.emptyList());
                     })
-                    .compose(storedSeatBids -> enrichAuctionContextWithBidResponse(auctionContext, storedSeatBids))
+                    .map(storedSeatBids -> enrichAuctionContextWithBidResponse(auctionContext, storedSeatBids))
                     .map(AuctionContext::skipAuction);
         }
 
@@ -94,10 +96,37 @@ private Future<List<SeatBid>> validateStoredSeatBid(List<SeatBid> seatBids) {
         return Future.succeededFuture(seatBids);
     }
 
-    private Future<AuctionContext> enrichAuctionContextWithBidResponse(AuctionContext auctionContext,
-                                                                       List<SeatBid> seatBids) {
+    private static AuctionContext enrichAuctionContextWithBidResponse(AuctionContext auctionContext,
+                                                                      List<SeatBid> seatBids) {
 
         auctionContext.getDebugWarnings().add("no auction. response defined by storedauctionresponse");
-        return bidResponseCreator.createOnSkippedAuction(auctionContext, seatBids).map(auctionContext::with);
+        return auctionContext.with(bidResponse(auctionContext, seatBids));
+    }
+
+    private static BidResponse bidResponse(AuctionContext auctionContext, List<SeatBid> seatBids) {
+        final BidRequest bidRequest = auctionContext.getBidRequest();
+        final ExtBidResponse extBidResponse = ExtBidResponse.builder()
+                .warnings(extractContextWarnings(auctionContext))
+                .tmaxrequest(bidRequest.getTmax())
+                .build();
+
+        final List<String> cur = bidRequest.getCur();
+
+        return BidResponse.builder()
+                .id(bidRequest.getId())
+                .cur(CollectionUtils.isNotEmpty(cur) ? cur.getFirst() : null)
+                .seatbid(ListUtils.emptyIfNull(seatBids))
+                .ext(extBidResponse)
+                .build();
+    }
+
+    private static Map<String, List<ExtBidderError>> extractContextWarnings(AuctionContext auctionContext) {
+        final List<ExtBidderError> contextWarnings = auctionContext.getDebugWarnings().stream()
+                .map(message -> ExtBidderError.of(BidderError.Type.generic.getCode(), message))
+                .toList();
+
+        return contextWarnings.isEmpty()
+                ? Collections.emptyMap()
+                : Collections.singletonMap("prebid", contextWarnings);
     }
 }

src/main/java/org/prebid/server/auction/StoredResponseProcessor.java

@@ -428,7 +428,7 @@ private BidderSeatBid makeBidderSeatBid(BidderSeatBid bidderSeatBid,
                 : DEFAULT_BID_CURRENCY;
         final List<BidderBid> bidderBids = seatBid != null
                 ? seatBid.getBid().stream()
-                .map(bid -> makeBidderBid(bid, bidCurrency, impIdToBidType))
+                .map(bid -> makeBidderBid(bid, bidCurrency, seatBid.getSeat(), impIdToBidType))
                 .collect(Collectors.toCollection(ArrayList::new))
                 : new ArrayList<>();
         if (nonNullBidderSeatBid) {
@@ -439,8 +439,8 @@ private BidderSeatBid makeBidderSeatBid(BidderSeatBid bidderSeatBid,
                 : BidderSeatBid.of(bidderBids);
     }
 
-    private BidderBid makeBidderBid(Bid bid, String bidCurrency, Map<String, BidType> impIdToBidType) {
-        return BidderBid.of(bid, getBidType(bid.getExt(), impIdToBidType.get(bid.getImpid())), bidCurrency);
+    private BidderBid makeBidderBid(Bid bid, String bidCurrency, String seat, Map<String, BidType> impIdToBidType) {
+        return BidderBid.of(bid, getBidType(bid.getExt(), impIdToBidType.get(bid.getImpid())), seat, bidCurrency);
     }
 
     private BidType getBidType(ObjectNode bidExt, BidType bidType) {

src/main/java/org/prebid/server/auction/UidUpdater.java

@@ -3,6 +3,7 @@
 import com.iab.openrtb.request.User;
 import org.apache.commons.collections4.map.CaseInsensitiveMap;
 import org.apache.commons.lang3.StringUtils;
+import org.prebid.server.auction.aliases.BidderAliases;
 import org.prebid.server.auction.model.AuctionContext;
 import org.prebid.server.bidder.BidderCatalog;
 import org.prebid.server.cookie.UidsCookie;

src/main/java/org/prebid/server/auction/adjustment/BidAdjustmentFactorResolver.java

@@ -14,25 +14,41 @@ public class BidAdjustmentFactorResolver {
 
     public BigDecimal resolve(ImpMediaType impMediaType,
                               ExtRequestBidAdjustmentFactors adjustmentFactors,
-                              String bidder) {
+                              String bidder,
+                              String seat) {
 
         final EnumMap<ImpMediaType, Map<String, BigDecimal>> adjustmentFactorsByMediaTypes =
                 adjustmentFactors.getMediatypes();
+        final Map<String, BigDecimal> adjustmentsFactors = adjustmentFactors.getAdjustments();
 
-        final BigDecimal effectiveBidderAdjustmentFactor = Optional.ofNullable(adjustmentFactors.getAdjustments())
-                .map(factors -> factors.get(bidder))
+        return resolveFromMediaTypes(impMediaType, seat, adjustmentFactorsByMediaTypes)
+                .or(() -> resolveFromAdjustments(seat, adjustmentsFactors))
+                .or(() -> resolveFromMediaTypes(impMediaType, bidder, adjustmentFactorsByMediaTypes))
+                .or(() -> resolveFromAdjustments(bidder, adjustmentsFactors))
                 .orElse(BigDecimal.ONE);
+    }
+
+    private static Optional<BigDecimal> resolveFromMediaTypes(
+            ImpMediaType mediaType,
+            String bidderCode,
+            EnumMap<ImpMediaType, Map<String, BigDecimal>> adjustmentFactors) {
 
-        if (MapUtils.isEmpty(adjustmentFactorsByMediaTypes)) {
-            return effectiveBidderAdjustmentFactor;
+        if (MapUtils.isEmpty(adjustmentFactors)) {
+            return Optional.empty();
         }
 
-        return Optional.ofNullable(impMediaType)
-                .map(adjustmentFactorsByMediaTypes::get)
+        return Optional.ofNullable(mediaType)
+                .map(adjustmentFactors::get)
                 .flatMap(factors -> factors.entrySet().stream()
-                        .filter(entry -> StringUtils.equalsIgnoreCase(entry.getKey(), bidder))
+                        .filter(entry -> StringUtils.equalsIgnoreCase(entry.getKey(), bidderCode))
                         .map(Map.Entry::getValue)
-                        .findFirst())
-                .orElse(effectiveBidderAdjustmentFactor);
+                        .findFirst());
+    }
+
+    private static Optional<BigDecimal> resolveFromAdjustments(String bidderCode,
+                                                               Map<String, BigDecimal> adjustmentFactors) {
+
+        return Optional.ofNullable(adjustmentFactors)
+                .map(factors -> factors.get(bidderCode));
     }
 }