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