Golang XML Unmarshal and time.Time fields

Question

I have XML data I am retrieving via a REST API that I am unmarshal-ing into a GO struct. One of the fields is a date field, however the date format returned by the API does not match the default time.Time parse format and thus the unmarshal fails.

Is there any way to specify to the unmarshal function which date format to use in the time.Time parsing? I'd like to use properly defined types and using a string to hold a datetime field feels wrong.

Sample struct:

type Transaction struct {

    Id int64 `xml:"sequencenumber"`
    ReferenceNumber string `xml:"ourref"`
    Description string `xml:"description"`
    Type string `xml:"type"`
    CustomerID string `xml:"namecode"`
    DateEntered time.Time `xml:"enterdate"` //this is the field in question
    Gross float64 `xml:"gross"`
    Container TransactionDetailContainer `xml:"subfile"`
}

The date format returned is "yyyymmdd".

This may help, even though it only deals with marshalling. https://groups.google.com/forum/#!topic/golang-nuts/IM3ZIcYXbz4 — Intermernet, Jun 25 '13 at 15:32
Also, have a look at https://code.google.com/p/go/issues/detail?id=2771 — Intermernet, Jun 25 '13 at 15:34

rougepied · Accepted Answer · 2015-04-23T14:23:53.763

61

I had the same problem.

time.Time doesn't satisfy the xml.Unmarshaler interface. And you can not specify a date fomat.

If you don't want to handle the parsing afterward and you prefer to let the xml.encoding do it, one solution is to create a struct with an anonymous time.Time field and implement your own UnmarshalXML with your custom date format.

type Transaction struct {
    //...
    DateEntered     customTime     `xml:"enterdate"` // use your own type that satisfies UnmarshalXML
    //...
}

type customTime struct {
    time.Time
}

func (c *customTime) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    const shortForm = "20060102" // yyyymmdd date format
    var v string
    d.DecodeElement(&v, &start)
    parse, err := time.Parse(shortForm, v)
    if err != nil {
        return err
    }
    *c = customTime{parse}
    return nil
}

If your XML element uses an attribut as a date, you have to implement UnmarshalXMLAttr the same way.

See http://play.golang.org/p/EFXZNsjE4a

edited Apr 23 '15 at 14:23

answered Jul 29 '14 at 12:24

rougepied

726
6
9

2

This got me down the right path. Was even easier to deal with when I did `customTime time.Time` instead - no need to deal with the underlying `time.Time` as a struct element. – Colselaw Feb 28 '17 at 22:43
3

Beware that DecodeElement returns an error, which should be checked and returned if not nil. – AndreiM Feb 06 '18 at 21:40
Out of curiosity, any drawbacks to using a type definition instead of an embedded type? i.e. `type customTime time.Time` – Spencer Kormos Jun 04 '20 at 17:50

score 4 · Answer 2 · answered Aug 16 '13 at 06:41

From what I have read the encoding/xml has some known issues that have been put off until a later date...

To get around this issue, instead of using the type time.Time use string and handle the parsing afterwards.

I had quite a bit of trouble getting time.Parse to work with dates in the following format: "Fri, 09 Aug 2013 19:39:39 GMT"

Oddly enough I found that "net/http" has a ParseTime function that takes a string that worked perfectly... http://golang.org/pkg/net/http/#ParseTime

Strangest thing, as soon as I set the type of a date field to string everything started parsing.... — Kristoffer Sall-Storgaard, Nov 12 '13 at 20:41

score 1 · Answer 3 · edited Jan 09 '18 at 21:00

1

I've implemented a xml dateTime format conforming a spec, you can find it on GitHub: https://github.com/datainq/xml-date-time

You can find XML dateTime in W3C spec

edited Jan 09 '18 at 21:00

snap

2,751
22
33

answered Sep 03 '17 at 20:27

Paweł Szczur

5,484
3
29
32

score 0 · Answer 4 · answered Feb 16 '23 at 20:29

A niche technique to override the JSON marshaling/unmarshaling of select keys in a struct is also applicable to XML marshaling/unmarshaling, with minimal modifications. The idea remains the same: Alias the original struct to hide the Unmarshal method, and embed the alias in another struct where individual fields may be overridden to allow the default unmarshaling method to apply.

In your example, following the idea above, I'd do it like this:

type TransactionA Transaction
type TransactionS struct {
    *TransactionA
    DateEntered string `xml:"enterdate"`
}

func (t *Transaction) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    const shortForm = "20060102" // yyyymmdd date format
    var s = &TransactionS{TransactionA: (*TransactionA)(t)}
    d.DecodeElement(s, &start)
    t.DateEntered, _ = time.Parse(shortForm, s.DateEntered)
    return nil
}

The smartest point of this method is, by sending TransactionS into DecodeElement, all fields of t gets populated through the embedded alias type *TransactionA, except for those overridden in the S-type. You can then process overridden struct members as you wish.

This approach scales very well if you have multiple fields of different types that you want to handle in a custom way, plus the benefit that you don't introduce an otherwise useless customType that you have to convert over and over again.

score -2 · Answer 5 · answered Jan 20 '15 at 00:20

-2

const shortForm = "20060102" // yyyymmdd date format

It is unreadable. But it is right in Go. You can read the source in http://golang.org/src/time/format.go

answered Jan 20 '15 at 00:20

fjjiaboming

191
1
3
11

Golang XML Unmarshal and time.Time fields

5 Answers5

Linked