-
Notifications
You must be signed in to change notification settings - Fork 689
/
axonix.go
131 lines (110 loc) · 3.32 KB
/
axonix.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
package axonix
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
"text/template"
"github.com/mxmCherry/openrtb/v15/openrtb2"
"github.com/prebid/prebid-server/adapters"
"github.com/prebid/prebid-server/config"
"github.com/prebid/prebid-server/errortypes"
"github.com/prebid/prebid-server/macros"
"github.com/prebid/prebid-server/openrtb_ext"
)
type adapter struct {
EndpointTemplate template.Template
}
func Builder(bidderName openrtb_ext.BidderName, config config.Adapter) (adapters.Bidder, error) {
endpoint, err := template.New("endpointTemplate").Parse(config.Endpoint)
if err != nil {
return nil, fmt.Errorf("unable to parse endpoint url template: %v", err)
}
bidder := &adapter{
EndpointTemplate: *endpoint,
}
return bidder, nil
}
func (a *adapter) getEndpoint(ext *openrtb_ext.ExtImpAxonix) (string, error) {
endpointParams := macros.EndpointTemplateParams{
AccountID: url.PathEscape(ext.SupplyId),
}
return macros.ResolveMacros(a.EndpointTemplate, endpointParams)
}
func (a *adapter) MakeRequests(request *openrtb2.BidRequest, requestInfo *adapters.ExtraRequestInfo) ([]*adapters.RequestData, []error) {
var errors []error
var bidderExt adapters.ExtImpBidder
if err := json.Unmarshal(request.Imp[0].Ext, &bidderExt); err != nil {
errors = append(errors, &errortypes.BadInput{
Message: err.Error(),
})
return nil, errors
}
var axonixExt openrtb_ext.ExtImpAxonix
if err := json.Unmarshal(bidderExt.Bidder, &axonixExt); err != nil {
errors = append(errors, &errortypes.BadInput{
Message: err.Error(),
})
return nil, errors
}
endpoint, err := a.getEndpoint(&axonixExt)
if err != nil {
errors = append(errors, err)
return nil, errors
}
requestJSON, err := json.Marshal(request)
if err != nil {
errors = append(errors, err)
return nil, errors
}
headers := http.Header{}
headers.Add("Content-Type", "application/json")
requestData := &adapters.RequestData{
Method: "POST",
Uri: endpoint,
Body: requestJSON,
Headers: headers,
}
return []*adapters.RequestData{requestData}, nil
}
func (a *adapter) MakeBids(request *openrtb2.BidRequest, requestData *adapters.RequestData, responseData *adapters.ResponseData) (*adapters.BidderResponse, []error) {
if responseData.StatusCode == http.StatusNoContent {
return nil, nil
}
if responseData.StatusCode != http.StatusOK {
err := &errortypes.BadServerResponse{
Message: fmt.Sprintf("Unexpected status code: %d.", responseData.StatusCode),
}
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
for _, seatBid := range response.SeatBid {
for _, bid := range seatBid.Bid {
bid := bid
b := &adapters.TypedBid{
Bid: &bid,
BidType: getMediaType(bid.ImpID, request.Imp),
}
bidResponse.Bids = append(bidResponse.Bids, b)
}
}
return bidResponse, nil
}
func getMediaType(impId string, imps []openrtb2.Imp) openrtb_ext.BidType {
for _, imp := range imps {
if imp.ID == impId {
if imp.Native != nil {
return openrtb_ext.BidTypeNative
} else if imp.Video != nil {
return openrtb_ext.BidTypeVideo
}
return openrtb_ext.BidTypeBanner
}
}
return openrtb_ext.BidTypeBanner
}