Update a few dependencies

github.com/go-openapi/*
github.com/asaskevich/govalidator

vendor/github.com/go-openapi/strfmt/time.go

@@ -16,11 +16,13 @@ package strfmt
 
 import (
 	"database/sql/driver"
+	"errors"
 	"fmt"
 	"regexp"
 	"strings"
 	"time"
 
+	"github.com/globalsign/mgo/bson"
 	"github.com/mailru/easyjson/jlexer"
 	"github.com/mailru/easyjson/jwriter"
 )
@@ -52,13 +54,17 @@ func IsDateTime(str string) bool {
 const (
 	// RFC3339Millis represents a ISO8601 format to millis instead of to nanos
 	RFC3339Millis = "2006-01-02T15:04:05.000Z07:00"
+	// RFC3339Micro represents a ISO8601 format to micro instead of to nano
+	RFC3339Micro = "2006-01-02T15:04:05.000000Z07:00"
 	// DateTimePattern pattern to match for the date-time format from http://tools.ietf.org/html/rfc3339#section-5.6
 	DateTimePattern = `^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$`
 )
 
 var (
-	dateTimeFormats = []string{RFC3339Millis, time.RFC3339, time.RFC3339Nano}
+	dateTimeFormats = []string{RFC3339Micro, RFC3339Millis, time.RFC3339, time.RFC3339Nano}
 	rxDateTime      = regexp.MustCompile(DateTimePattern)
+	// MarshalFormat sets the time resolution format used for marshaling time (set to milliseconds)
+	MarshalFormat = RFC3339Millis
 )
 
 // ParseDateTime parses a string that represents an ISO8601 time or a unix epoch
@@ -81,7 +87,8 @@ func ParseDateTime(data string) (DateTime, error) {
 
 // DateTime is a time but it serializes to ISO8601 format with millis
 // It knows how to read 3 different variations of a RFC3339 date time.
-// Most API's we encounter want either millisecond or second precision times. This just tries to make it worry-free.
+// Most APIs we encounter want either millisecond or second precision times.
+// This just tries to make it worry-free.
 //
 // swagger:strfmt date-time
 type DateTime time.Time
@@ -91,8 +98,9 @@ func NewDateTime() DateTime {
 	return DateTime(time.Unix(0, 0).UTC())
 }
 
+// String converts this time to a string
 func (t DateTime) String() string {
-	return time.Time(t).Format(RFC3339Millis)
+	return time.Time(t).Format(MarshalFormat)
 }
 
 // MarshalText implements the text marshaller interface
@@ -131,25 +139,29 @@ func (t *DateTime) Scan(raw interface{}) error {
 
 // Value converts DateTime to a primitive value ready to written to a database.
 func (t DateTime) Value() (driver.Value, error) {
-	return driver.Value(t), nil
+	return driver.Value(t.String()), nil
 }
 
+// MarshalJSON returns the DateTime as JSON
 func (t DateTime) MarshalJSON() ([]byte, error) {
 	var w jwriter.Writer
 	t.MarshalEasyJSON(&w)
 	return w.BuildBytes()
 }
 
+// MarshalEasyJSON writes the DateTime to a easyjson.Writer
 func (t DateTime) MarshalEasyJSON(w *jwriter.Writer) {
-	w.String(time.Time(t).Format(RFC3339Millis))
+	w.String(time.Time(t).Format(MarshalFormat))
 }
 
+// UnmarshalJSON sets the DateTime from JSON
 func (t *DateTime) UnmarshalJSON(data []byte) error {
 	l := jlexer.Lexer{Data: data}
 	t.UnmarshalEasyJSON(&l)
 	return l.Error()
 }
 
+// UnmarshalEasyJSON sets the DateTime from a easyjson.Lexer
 func (t *DateTime) UnmarshalEasyJSON(in *jlexer.Lexer) {
 	if data := in.String(); in.Ok() {
 		tt, err := ParseDateTime(data)
@@ -160,3 +172,24 @@ func (t *DateTime) UnmarshalEasyJSON(in *jlexer.Lexer) {
 		*t = tt
 	}
 }
+
+// GetBSON returns the DateTime as a bson.M{} map.
+func (t *DateTime) GetBSON() (interface{}, error) {
+	return bson.M{"data": t.String()}, nil
+}
+
+// SetBSON sets the DateTime from raw bson data
+func (t *DateTime) SetBSON(raw bson.Raw) error {
+	var m bson.M
+	if err := raw.Unmarshal(&m); err != nil {
+		return err
+	}
+
+	if data, ok := m["data"].(string); ok {
+		var err error
+		*t, err = ParseDateTime(data)
+		return err
+	}
+
+	return errors.New("couldn't unmarshal bson raw value as Duration")
+}