Add native object to impression

Author: GiPPe

asset.go

@@ -0,0 +1,44 @@
+package openrtb
+
+// TODO: Add description, use cases and other details
+type Asset struct {
+	Id       *int         `json:"id"`                 // Unique asset ID, assigned by exchange
+	Required *int         `json:"required,omitempty"` // Set to 1 if asset is required
+	Title    *Title       `json:"title,omitempty"`    // Title object for title assets
+	Img      *Image       `json:"img,omitempty"`      // Image object for image assets
+	Video    *NativeVideo `json:"video,omitempty"`    // Video object for video assets
+	Data     *NativeData  `json:"data,omitempty"`     // Data object for ratings, price, etc.
+	Ext      Extensions   `json:"ext,omitempty"`
+}
+
+type Title struct {
+	Len *int       `json:"len"` // Maximum length of the text in the title element
+	Ext Extensions `json:"ext,omitempty"`
+}
+
+type Image struct {
+	Type  *int       `json:"type,omitempty"`  // Type ID of the image element supported by the publisher
+	W     *int       `json:"w,omitempty"`     // Width
+	H     *int       `json:"h,omitempty"`     // Height
+	Wmax  *int       `json:"wmax,omitempty"`  // Width maximum
+	Hmax  *int       `json:"hmax,omitempty"`  // Height maximum
+	Wmin  *int       `json:"wmin,omitempty"`  // Width minimum
+	Hmin  *int       `json:"hmin,omitempty"`  // Height minimum
+	Mimes []string   `json:"mimes,omitempty"` // Whitelist of content MIME types supported
+	Ext   Extensions `json:"ext,omitempty"`
+}
+
+type NativeData struct {
+	Type *int       `json:"type"`          // Type ID of the image element supported by the publisher
+	Len  *int       `json:"len,omitempty"` // Maximum length of the text in the element’s response
+	Ext  Extensions `json:"ext,omitempty"`
+}
+
+// Applies defaults
+func (a *Asset) WithDefaults() *Asset {
+	if a.Required == nil {
+		a.Required = new(int)
+		*a.Required = 0
+	}
+	return a
+}

asset_test.go

@@ -0,0 +1,19 @@
+package openrtb
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Asset", func() {
+	var subject *Asset
+
+	BeforeEach(func() {
+		subject = new(Asset)
+	})
+
+	It("should have defaults", func() {
+		subject.WithDefaults()
+		Expect(*subject.Required).To(Equal(0))
+	})
+})

impression.go

@@ -13,6 +13,7 @@ type Impression struct {
 	Id                *string    `json:"id"` // A unique identifier for this impression
 	Banner            *Banner    `json:"banner,omitempty"`
 	Video             *Video     `json:"video,omitempty"`
+	Native            *Native    `json:"native,omitempty"`
 	Displaymanager    *string    `json:"displaymanager,omitempty"`    // Name of ad mediation partner, SDK technology, etc
 	Displaymanagerver *string    `json:"displaymanagerver,omitempty"` // Version of the above
 	Instl             *int       `json:"instl,omitempty"`             // Interstitial, Default: 0 ("1": Interstitial, "0": Something else)

native.go

@@ -0,0 +1,29 @@
+package openrtb
+
+// TODO: Add description, use cases and other details
+type Native struct {
+	Ver      *string    `json:"ver,omitempty"`      // Version of the Native Markup version in use
+	Layout   *int       `json:"layout,omitempty"`   // Layout ID of the native ad unit
+	Adunit   *int       `json:"adunit,omitempty"`   // Ad unit ID of the native ad unit
+	Plcmtcnt *int       `json:"plcmtcnt,omitempty"` // Number of identical placements in this Layout
+	Seq      *int       `json:"seq,omitempty"`      // This is not the sequence number of the content in the stream
+	Assets   []Asset    `json:"assets"`             // Array of Asset Objects
+	Ext      Extensions `json:"ext,omitempty"`
+}
+
+// Applies defaults
+func (n *Native) WithDefaults() *Native {
+	if n.Ver == nil {
+		n.Ver = new(string)
+		*n.Ver = "1"
+	}
+	if n.Plcmtcnt == nil {
+		n.Plcmtcnt = new(int)
+		*n.Plcmtcnt = 1
+	}
+	if n.Seq == nil {
+		n.Seq = new(int)
+		*n.Seq = 0
+	}
+	return n
+}

native_test.go

@@ -0,0 +1,21 @@
+package openrtb
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Native", func() {
+	var subject *Native
+
+	BeforeEach(func() {
+		subject = new(Native)
+	})
+
+	It("should have defaults", func() {
+		subject.WithDefaults()
+		Expect(*subject.Ver).To(Equal("1"))
+		Expect(*subject.Plcmtcnt).To(Equal(1))
+		Expect(*subject.Seq).To(Equal(0))
+	})
+})

native_video.go

@@ -0,0 +1,121 @@
+package openrtb
+
+// The "video" object must be included directly in the impression object if the impression offered
+// for auction is an in-stream video ad opportunity.
+type NativeVideo struct {
+	Mimes          []string   `json:"mimes"`                    // Content MIME types supported.
+	Minduration    *int       `json:"minduration"`              // Minimum video ad duration in seconds
+	Maxduration    *int       `json:"maxduration"`              // Maximum video ad duration in seconds
+	Protocol       *int       `json:"protocol,omitempty"`       // Video bid response protocols
+	Protocols      []int      `json:"protocols"`                // Video bid response protocols
+	W              *int       `json:"w,omitempty"`              // Width of the player in pixels
+	H              *int       `json:"h,omitempty"`              // Height of the player in pixels
+	Startdelay     *int       `json:"startdelay,omitempty"`     // Indicates the start delay in seconds
+	Linearity      *int       `json:"linearity,omitempty"`      // Indicates whether the ad impression is linear or non-linear
+	Sequence       *int       `json:"sequence,omitempty"`       // Default: 1
+	Battr          []int      `json:"battr,omitempty"`          // Blocked creative attributes
+	Maxextended    *int       `json:"maxextended,omitempty"`    // Maximum extended video ad duration
+	Minbitrate     *int       `json:"minbitrate,omitempty"`     // Minimum bit rate in Kbps
+	Maxbitrate     *int       `json:"maxbitrate,omitempty"`     // Maximum bit rate in Kbps
+	Boxingallowed  *int       `json:"boxingallowed,omitempty"`  // If exchange publisher has rules preventing letter boxing
+	Playbackmethod []int      `json:"playbackmethod,omitempty"` // List of allowed playback methods
+	Delivery       []int      `json:"delivery,omitempty"`       // List of supported delivery methods
+	Pos            *int       `json:"pos,omitempty"`            // Ad Position
+	Companionad    []Banner   `json:"companionad,omitempty"`
+	Api            []int      `json:"api,omitempty"` // List of supported API frameworks
+	Companiontype  []int      `json:"companiontype,omitempty"`
+	Ext            Extensions `json:"ext,omitempty"`
+}
+
+// Returns the sequence number, with default fallback
+func (v *NativeVideo) Seq() int {
+	if v.Sequence != nil {
+		return *v.Sequence
+	}
+	return 1
+}
+
+// Returns the boxing permission status, with default fallback
+func (v *NativeVideo) IsBoxingAllowed() bool {
+	if v.Boxingallowed != nil {
+		return *v.Boxingallowed == 1
+	}
+	return true
+}
+
+// Returns the position, with default fallback
+func (v *NativeVideo) Position() int {
+	if v.Pos != nil {
+		return *v.Pos
+	}
+	return AD_POS_UNKNOWN
+}
+
+// Validates the object
+func (v *NativeVideo) Valid() (bool, error) {
+	if len(v.Mimes) == 0 {
+		return false, ErrInvalidVideoMimes
+	} else if v.Linearity == nil {
+		return false, ErrInvalidVideoLinearity
+	} else if v.Minduration == nil {
+		return false, ErrInvalidVideoMinduration
+	} else if v.Maxduration == nil {
+		return false, ErrInvalidVideoMaxduration
+	} else if v.Protocol == nil {
+		return false, ErrInvalidVideoProtocol
+	}
+	return true, nil
+}
+
+// Applies defaults
+func (v *NativeVideo) WithDefaults() *NativeVideo {
+	if v.Sequence == nil {
+		v.Sequence = new(int)
+		*v.Sequence = 1
+	}
+	if v.Boxingallowed == nil {
+		v.Boxingallowed = new(int)
+		*v.Boxingallowed = 1
+	}
+	if v.Pos == nil {
+		v.Pos = new(int)
+		*v.Pos = AD_POS_UNKNOWN
+	}
+	return v
+}
+
+// Set the Linearity
+func (v *NativeVideo) SetLinearity(lin int) *NativeVideo {
+	if v.Linearity == nil {
+		v.Linearity = new(int)
+	}
+	*v.Linearity = lin
+	return v
+}
+
+// Set the Minduration
+func (v *NativeVideo) SetMinduration(mdur int) *NativeVideo {
+	if v.Minduration == nil {
+		v.Minduration = new(int)
+	}
+	*v.Minduration = mdur
+	return v
+}
+
+// Set the Maxduration
+func (v *NativeVideo) SetMaxduration(mdur int) *NativeVideo {
+	if v.Maxduration == nil {
+		v.Maxduration = new(int)
+	}
+	*v.Maxduration = mdur
+	return v
+}
+
+// Set the Protocol
+func (v *NativeVideo) SetProtocol(p int) *NativeVideo {
+	if v.Protocol == nil {
+		v.Protocol = new(int)
+	}
+	*v.Protocol = p
+	return v
+}

native_video_test.go

@@ -0,0 +1,75 @@
+package openrtb
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("NativeVideo", func() {
+	var subject *NativeVideo
+
+	BeforeEach(func() { subject = new(NativeVideo) })
+
+	Describe("Seq()", func() {
+		It("should return '1' as default", func() {
+			Expect(subject.Seq()).To(Equal(1))
+		})
+	})
+
+	Describe("IsBoxingAllowed()", func() {
+		It("should return true as default", func() {
+			Expect(subject.IsBoxingAllowed()).To(BeTrue())
+		})
+
+		It("should return false when set as false", func() {
+			subject.Boxingallowed = new(int)
+			*subject.Boxingallowed = 0
+			Expect(subject.IsBoxingAllowed()).To(BeFalse())
+		})
+	})
+
+	Describe("Position()", func() {
+		It("should return 0/AD_POST_UNKNOWN as default", func() {
+			Expect(subject.Position()).To(Equal(0))
+		})
+	})
+
+	Describe("Valid()", func() {
+		It("should return error messages when attributes missing", func() {
+			ok, err := subject.Valid()
+			Expect(err.Error()).To(Equal("openrtb parse: video has no mimes"))
+
+			subject.Mimes = []string{"RAND_KEY"} // With Mimes
+			ok, err = subject.Valid()
+			Expect(err.Error()).To(Equal("openrtb parse: video linearity missing"))
+
+			subject.SetLinearity(2) // With Linearity
+			ok, err = subject.Valid()
+			Expect(err.Error()).To(Equal("openrtb parse: video minduration missing"))
+
+			subject.SetMinduration(1) // With Minduration
+			ok, err = subject.Valid()
+			Expect(err.Error()).To(Equal("openrtb parse: video maxduration missing"))
+
+			subject.SetMaxduration(5) // With Maxduration
+			ok, err = subject.Valid()
+			Expect(err.Error()).To(Equal("openrtb parse: video protocol missing"))
+
+			subject.SetProtocol(1) // With Protocol
+			ok, err = subject.Valid()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(ok).To(BeTrue())
+		})
+	})
+
+	Describe("WithDefaults()", func() {
+
+		It("should return object with default values", func() {
+			subject.WithDefaults()
+			Expect(*subject.Sequence).To(Equal(1))
+			Expect(*subject.Boxingallowed).To(Equal(1))
+			Expect(*subject.Pos).To(Equal(AD_POS_UNKNOWN))
+		})
+	})
+
+})