Split into separate object files. Extract validations & defaults into public methods.

Author: dim

app.go

@@ -0,0 +1,51 @@
+package openrtb
+
+// An "app" object should be included if the ad supported content is part of a mobile application
+// (as opposed to a mobile website).  A bid request must not contain both an "app" object and a
+// "site" object.
+type App struct {
+	Id            *string // App ID on the exchange
+	Name          *string // App name
+	Domain        *string
+	Cat           []string // Array of IAB content categories
+	Sectioncat    []string // Array of IAB content categories for subsection
+	Pagecat       []string // Array of IAB content categories for page
+	Ver           *string  // App version
+	Bundle        *string  // App bundle or package name
+	Privacypolicy *int     // Default: 1 ("1": site has a privacy policy)
+	Paid          *int     // "1": Paid, "2": Free
+	Publisher     *Publisher
+	// Content       Content
+	Keywords []string
+	Storeurl *string // App store URL for an installed app
+	Ext      Extensions
+}
+
+// Returns the privacy policy status, with default fallback
+func (a *App) IsPrivacyPolicy() bool {
+	if a.Privacypolicy != nil {
+		return *a.Privacypolicy == 1
+	}
+	return false
+}
+
+// Returns the paid status, with default fallback
+func (a *App) IsPaid() bool {
+	if a.Paid != nil {
+		return *a.Paid == 1
+	}
+	return false
+}
+
+// Applies defaults
+func (a *App) WithDefaults() *App {
+	if a.Privacypolicy == nil {
+		a.Privacypolicy = new(int)
+		*a.Privacypolicy = 0
+	}
+	if a.Paid == nil {
+		a.Paid = new(int)
+		*a.Paid = 0
+	}
+	return a
+}

app_test.go

@@ -0,0 +1,20 @@
+package openrtb
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestApp_IsPrivacyPolicy(t *testing.T) {
+	a := &App{}
+	assert.Equal(t, a.IsPrivacyPolicy(), false)
+}
+
+func TestApp_IsPaid(t *testing.T) {
+	a := &App{}
+	assert.Equal(t, a.IsPaid(), false)
+}
+
+func TestApp_WithDefaults(t *testing.T) {
+	assert.Equal(t, "pending", "TODO")
+}

banner.go

@@ -0,0 +1,50 @@
+package openrtb
+
+// The "banner" object must be included directly in the impression object if the impression offered
+// for auction is display or rich media, or it may be optionally embedded in the video object to
+// describe the companion banners available for the linear or non-linear video ad.  The banner
+// object may include a unique identifier; this can be useful if these IDs can be leveraged in the
+// VAST response to dictate placement of the companion creatives when multiple companion ad
+// opportunities of the same size are available on a page.
+type Banner struct {
+	W        *int     // Width
+	H        *int     // Height
+	Id       *string  // A unique identifier
+	Pos      *int     // Ad Position
+	Btype    []int    // Blocked creative types
+	Battr    []int    // Blocked creative attributes
+	Mimes    []string // Whitelist of content MIME types supported
+	Topframe *int     // Default: 0 ("1": Delivered in top frame, "0": Elsewhere)
+	Expdir   []int    // Specify properties for an expandable ad
+	Api      []int    // List of supported API frameworks
+	Ext      Extensions
+}
+
+// Returns topframe status, with default fallback
+func (b *Banner) IsTopFrame() bool {
+	if b.Topframe != nil {
+		return *b.Topframe == 1
+	}
+	return false
+}
+
+// Returns the position, with default fallback
+func (b *Banner) Position() int {
+	if b.Pos != nil {
+		return *b.Pos
+	}
+	return AD_POS_UNKNOWN
+}
+
+// Applies defaults
+func (b *Banner) WithDefaults() *Banner {
+	if b.Topframe == nil {
+		b.Topframe = new(int)
+		*b.Topframe = 0
+	}
+	if b.Pos == nil {
+		b.Pos = new(int)
+		*b.Pos = AD_POS_UNKNOWN
+	}
+	return b
+}

banner_test.go

@@ -0,0 +1,20 @@
+package openrtb
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestBanner_IsTopFrame(t *testing.T) {
+	b := &Banner{}
+	assert.Equal(t, b.IsTopFrame(), false)
+}
+
+func TestBanner_Position(t *testing.T) {
+	b := &Banner{}
+	assert.Equal(t, b.Position(), 0)
+}
+
+func TestBanner_WithDefaults(t *testing.T) {
+	assert.Equal(t, "pending", "TODO")
+}

device.go

@@ -0,0 +1,80 @@
+package openrtb
+
+// The "device" object provides information pertaining to the device including its hardware,
+// platform, location, and carrier. This device can refer to a mobile handset, a desktop computer,
+// set top box or other digital device.
+type Device struct {
+	Dnt            *int    // "1": Do not track
+	Ua             *string // User agent
+	Ip             *string // IPv4
+	Geo            *Geo
+	Didsha1        *string // SHA1 hashed device ID
+	Didmd5         *string // MD5 hashed device ID
+	Dpidsha1       *string // SHA1 hashed platform device ID
+	Dpidmd5        *string // MD5 hashed platform device ID
+	Ipv6           *string // IPv6
+	Carrier        *string // Carrier or ISP derived from the IP address
+	Language       *string // Browser language
+	Make           *string // Device make
+	Model          *string // Device model
+	Os             *string // Device OS
+	Osv            *string // Device OS version
+	Js             *int    // Javascript status ("0": Disabled, "1": Enabled)
+	Connectiontype *int
+	Devicetype     *int
+	Flashver       *string // Flash version
+	Ext            map[string]string
+}
+
+// Returns the DNT status, with default fallback
+func (d *Device) IsDnt() bool {
+	if d.Dnt != nil {
+		return *d.Dnt == 1
+	}
+	return false
+}
+
+// Returns the JS status, with default fallback
+func (d *Device) IsJs() bool {
+	if d.Js != nil {
+		return *d.Js == 1
+	}
+	return false
+}
+
+// Returns the connection type, with default fallback
+func (d *Device) ConnectionType() int {
+	if d.Connectiontype != nil {
+		return *d.Connectiontype
+	}
+	return CONN_TYPE_UNKNOWN
+}
+
+// Returns the connection type, with default fallback
+func (d *Device) DeviceType() int {
+	if d.Devicetype != nil {
+		return *d.Devicetype
+	}
+	return DEVICE_TYPE_UNKNOWN
+}
+
+// Applies defaults
+func (d *Device) WithDefaults() *Device {
+	if d.Dnt == nil {
+		d.Dnt = new(int)
+		*d.Dnt = 0
+	}
+	if d.Js == nil {
+		d.Js = new(int)
+		*d.Js = 0
+	}
+	if d.Connectiontype == nil {
+		d.Connectiontype = new(int)
+		*d.Connectiontype = CONN_TYPE_UNKNOWN
+	}
+	if d.Devicetype == nil {
+		d.Devicetype = new(int)
+		*d.Devicetype = DEVICE_TYPE_UNKNOWN
+	}
+	return d
+}

device_test.go

@@ -0,0 +1,30 @@
+package openrtb
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestDevice_IsDnt(t *testing.T) {
+	d := &Device{}
+	assert.Equal(t, d.IsDnt(), false)
+}
+
+func TestDevice_IsJs(t *testing.T) {
+	d := &Device{}
+	assert.Equal(t, d.IsJs(), false)
+}
+
+func TestDevice_ConnectionType(t *testing.T) {
+	d := &Device{}
+	assert.Equal(t, d.ConnectionType(), 0)
+}
+
+func TestDevice_DeviceType(t *testing.T) {
+	d := &Device{}
+	assert.Equal(t, d.DeviceType(), 0)
+}
+
+func TestDevice_WithDefaults(t *testing.T) {
+	assert.Equal(t, "pending", "TODO")
+}

impression.go

@@ -0,0 +1,66 @@
+package openrtb
+
+// The "imp" object describes the ad position or impression being auctioned.  A single bid request
+// can include multiple "imp" objects, a use case for which might be an exchange that supports
+// selling all ad positions on a given page as a bundle.  Each "imp" object has a required ID so that
+// bids can reference them individually.  An exchange can also conduct private auctions by
+// restricting involvement to specific subsets of seats within bidders.
+type Impression struct {
+	Id                *string // A unique identifier for this impression
+	Banner            *Banner
+	Video             *Video
+	Displaymanager    *string  // Name of ad mediation partner, SDK technology, etc
+	Displaymanagerver *string  // Version of the above
+	Instl             *int     // Interstitial, Default: 0 ("1": Interstitial, "0": Something else)
+	Tagid             *string  // Identifier for specific ad placement or ad tag
+	Bidfloor          *float32 // Bid floor for this impression in CPM
+	Bidfloorcur       *string  // Currency of bid floor
+	Iframebuster      []string // Array of names for supportediframe busters.
+	Ext               Extensions
+}
+
+// Validates the `imp` object
+func (imp *Impression) Valid() (bool, error) {
+
+	if imp.Id == nil {
+		return false, errValidationImpId
+	} else if imp.Banner != nil && imp.Video != nil {
+		return false, errValidationImpBaV
+	} else if imp.Video != nil {
+		if ok, err := imp.Video.Valid(); !ok {
+			return ok, err
+		}
+	} else {
+		return false, errValidationImpBoV
+	}
+
+	return true, nil
+}
+
+// Returns the `imp` object returning defaults
+func (imp *Impression) WithDefaults() *Impression {
+	if imp.Instl == nil {
+		imp.Instl = new(int)
+		*imp.Instl = 0
+	}
+
+	if imp.Bidfloor == nil {
+		imp.Bidfloor = new(float32)
+		*imp.Bidfloor = 0
+	}
+
+	if imp.Bidfloorcur == nil {
+		imp.Bidfloorcur = new(string)
+		*imp.Bidfloorcur = "USD"
+	}
+
+	if imp.Banner != nil {
+		imp.Banner.WithDefaults()
+	}
+
+	if imp.Video != nil {
+		imp.Video.WithDefaults()
+	}
+
+	return imp
+}

impression_test.go

@@ -0,0 +1,14 @@
+package openrtb
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestImpression_Valid(t *testing.T) {
+	assert.Equal(t, "pending", "TODO")
+}
+
+func TestImpression_WithDefaults(t *testing.T) {
+	assert.Equal(t, "pending", "TODO")
+}