github.com/prebid/prebid-server@v0.275.0/adapters/emtv/emtv.go (about)

     1  package emtv
     2  
     3  import (
     4  	"encoding/json"
     5  	"errors"
     6  	"fmt"
     7  	"net/http"
     8  
     9  	"github.com/prebid/openrtb/v19/openrtb2"
    10  	"github.com/prebid/prebid-server/adapters"
    11  	"github.com/prebid/prebid-server/config"
    12  	"github.com/prebid/prebid-server/errortypes"
    13  	"github.com/prebid/prebid-server/openrtb_ext"
    14  )
    15  
    16  type adapter struct {
    17  	endpoint string
    18  }
    19  
    20  type reqBodyExt struct {
    21  	EmtvBidderExt reqBodyExtBidder `json:"bidder"`
    22  }
    23  
    24  type reqBodyExtBidder struct {
    25  	Type        string `json:"type"`
    26  	PlacementID string `json:"placementId,omitempty"`
    27  	EndpointID  string `json:"endpointId,omitempty"`
    28  }
    29  
    30  func Builder(bidderName openrtb_ext.BidderName, config config.Adapter, server config.Server) (adapters.Bidder, error) {
    31  	bidder := &adapter{
    32  		endpoint: config.Endpoint,
    33  	}
    34  	return bidder, nil
    35  }
    36  
    37  func (a *adapter) MakeRequests(request *openrtb2.BidRequest, reqInfo *adapters.ExtraRequestInfo) ([]*adapters.RequestData, []error) {
    38  	var err error
    39  	var adapterRequests []*adapters.RequestData
    40  
    41  	reqCopy := *request
    42  	for _, imp := range request.Imp {
    43  		reqCopy.Imp = []openrtb2.Imp{imp}
    44  
    45  		var bidderExt adapters.ExtImpBidder
    46  		var emtvExt openrtb_ext.ImpExtEmtv
    47  
    48  		if err = json.Unmarshal(reqCopy.Imp[0].Ext, &bidderExt); err != nil {
    49  			return nil, []error{err}
    50  		}
    51  		if err = json.Unmarshal(bidderExt.Bidder, &emtvExt); err != nil {
    52  			return nil, []error{err}
    53  		}
    54  
    55  		impExt := reqBodyExt{EmtvBidderExt: reqBodyExtBidder{}}
    56  
    57  		if emtvExt.PlacementID != "" {
    58  			impExt.EmtvBidderExt.PlacementID = emtvExt.PlacementID
    59  			impExt.EmtvBidderExt.Type = "publisher"
    60  		} else if emtvExt.EndpointID != "" {
    61  			impExt.EmtvBidderExt.EndpointID = emtvExt.EndpointID
    62  			impExt.EmtvBidderExt.Type = "network"
    63  		} else {
    64  			continue
    65  		}
    66  
    67  		finalyImpExt, err := json.Marshal(impExt)
    68  		if err != nil {
    69  			return nil, []error{err}
    70  		}
    71  
    72  		reqCopy.Imp[0].Ext = finalyImpExt
    73  
    74  		adapterReq, err := a.makeRequest(&reqCopy)
    75  		if err != nil {
    76  			return nil, []error{err}
    77  		}
    78  
    79  		if adapterReq != nil {
    80  			adapterRequests = append(adapterRequests, adapterReq)
    81  		}
    82  	}
    83  
    84  	if len(adapterRequests) == 0 {
    85  		return nil, []error{errors.New("found no valid impressions")}
    86  	}
    87  
    88  	return adapterRequests, nil
    89  }
    90  
    91  func (a *adapter) makeRequest(request *openrtb2.BidRequest) (*adapters.RequestData, error) {
    92  	reqJSON, err := json.Marshal(request)
    93  	if err != nil {
    94  		return nil, err
    95  	}
    96  
    97  	headers := http.Header{}
    98  	headers.Add("Content-Type", "application/json;charset=utf-8")
    99  	headers.Add("Accept", "application/json")
   100  	return &adapters.RequestData{
   101  		Method:  "POST",
   102  		Uri:     a.endpoint,
   103  		Body:    reqJSON,
   104  		Headers: headers,
   105  	}, nil
   106  }
   107  
   108  func (a *adapter) MakeBids(request *openrtb2.BidRequest, requestData *adapters.RequestData, responseData *adapters.ResponseData) (*adapters.BidderResponse, []error) {
   109  	if adapters.IsResponseStatusCodeNoContent(responseData) {
   110  		return nil, nil
   111  	}
   112  
   113  	if err := adapters.CheckResponseStatusCodeForErrors(responseData); err != nil {
   114  		return nil, []error{err}
   115  	}
   116  
   117  	var response openrtb2.BidResponse
   118  	if err := json.Unmarshal(responseData.Body, &response); err != nil {
   119  		return nil, []error{err}
   120  	}
   121  
   122  	bidResponse := adapters.NewBidderResponseWithBidsCapacity(len(request.Imp))
   123  	bidResponse.Currency = response.Cur
   124  
   125  	impsMappedByID := make(map[string]openrtb2.Imp, len(request.Imp))
   126  	for i, imp := range request.Imp {
   127  		impsMappedByID[request.Imp[i].ID] = imp
   128  	}
   129  
   130  	for _, seatBid := range response.SeatBid {
   131  		for i := range seatBid.Bid {
   132  			bidType, err := getMediaTypeForImp(seatBid.Bid[i].ImpID, request.Imp, impsMappedByID)
   133  			if err != nil {
   134  				return nil, []error{err}
   135  			}
   136  
   137  			b := &adapters.TypedBid{
   138  				Bid:     &seatBid.Bid[i],
   139  				BidType: bidType,
   140  			}
   141  			bidResponse.Bids = append(bidResponse.Bids, b)
   142  		}
   143  	}
   144  	return bidResponse, nil
   145  }
   146  
   147  func getMediaTypeForImp(impID string, imps []openrtb2.Imp, impMap map[string]openrtb2.Imp) (openrtb_ext.BidType, error) {
   148  	if index, found := impMap[impID]; found {
   149  		if index.Banner != nil {
   150  			return openrtb_ext.BidTypeBanner, nil
   151  		}
   152  		if index.Video != nil {
   153  			return openrtb_ext.BidTypeVideo, nil
   154  		}
   155  		if index.Native != nil {
   156  			return openrtb_ext.BidTypeNative, nil
   157  		}
   158  	}
   159  
   160  	return "", &errortypes.BadInput{
   161  		Message: fmt.Sprintf("Failed to find impression \"%s\"", impID),
   162  	}
   163  }