Multiple custom time formats in go for JSON Marshall

I have a utility function for marshalling and unmarshalling custom time formats in go that is working fine for one format string and is used in a JSON model as follows

    type Entry struct {
    	ID                int              `json:"id"`
    	AuthorisedBy      string           `json:"authorisedBy"`
    	Duid              string           `json:"duid"`
    	IntervalCount     int32            `json:"intervalCount"`
    	Intervals         []int32          `json:"intervals"`
    	RequestId         string           `json:"requestId"`
    	RequestTimestamp  time.Time        `json:"requestTimestamp"`
    	TradingDate       utils.CustomTime `json:"tradingDate"`
    	Unit              string           `json:"unit"`
    	RebidExplanation  string           `json:"rebidexplanation"`
    	AcceptedTimestamp time.Time        `json:"acceptedTimestamp"`
}

The utility function being.

package utils

import (
	"database/sql/driver"
	"fmt"
	"strings"
	"time"
)

type CustomTime struct {
	time.Time,
}

const ctLayout = "2006-01-02"

func (ct *CustomTime) UnmarshalJSON(b []byte) (err error) {
	s := strings.Trim(string(b), "\"")
	if s == "null" {
		ct.Time = time.Time{}
		return
	}
	ct.Time, err = time.Parse(ctLayout, s)
	return
}

func (ct *CustomTime) MarshalJSON() ([]byte, error) {
	if ct.Time.UnixNano() == nilTime {
		return []byte("null"), nil
	}
	return []byte(fmt.Sprintf("\"%s\"", ct.Time.Format(ctLayout))), nil
}

var nilTime = (time.Time{}).UnixNano()

func (ct *CustomTime) IsSet() bool {
	return ct.UnixNano() != nilTime
}

func (c CustomTime) Value() (driver.Value, error) {
	return driver.Value(c.Time), nil
}

func (c *CustomTime) Scan(src interface{}) error {
	switch t := src.(type) {
	case time.Time:
		c.Time = t
		return nil
	default:
		return fmt.Errorf("column type not supported")
	}
}

My issues, is that I now need to format one of the other fields with exactly 3ms fields such as ctLayout = "2006-01-02 15:04:05.000".

My question is, how do I set this up so I don't need to duplicate the entire structure, Is there a way I can pass in the ctLayout string in the Entry structure and pick it up in the utility function. I'm sure there is, but I can't for the life of me work out how.

If I need to create a CustomTimeMS class, then so be it, but it seems like a lot of duplicate code.

Thanks.

Two ways:

One

Add an exported field CTLayout to struct Entry

type Entry struct {
        ID                int              `json:"id"`
        AuthorisedBy      string           `json:"authorisedBy"`
        ...
        ...
        AcceptedTimestamp time.Time        `json:"acceptedTimestamp"`
        CTLayout          string           `json:"-"`
}

Update the MarshalJSON function

func (ct *CustomTime) MarshalJSON() ([]byte, error) {
    if ct.Time.UnixNano() == nilTime {
        return []byte("null"), nil
    }
    return []byte(fmt.Sprintf("\"%s\"", ct.Time.Format(ct.CTLayout))), nil
}

Since CTLayout is exported it's accessible from anywhere.

Update CTLayout with what you need before calling json.Marshal on the CustomTime value

====================================

Two

Add an unexported field

type Entry struct {
        ID                int              `json:"id"`
        AuthorisedBy      string           `json:"authorisedBy"`
        ...
        ...
        AcceptedTimestamp time.Time        `json:"acceptedTimestamp"`
        ctLayout          string
}

update the MarshalJSON function

func (ct *CustomTime) MarshalJSON() ([]byte, error) {
    if ct.Time.UnixNano() == nilTime {
        return []byte("null"), nil
    }
    return []byte(fmt.Sprintf("\"%s\"", ct.Time.Format(ct.ctLayout))), nil
}

create a exported helper marshal function

func (ct *CustomTime) Marshal(ctLayout string) ([]byte, error) {
        // You can do whatever else you want here
        // we'll do the obvious
        ct.ctLayout = ctLayout
        return ct.MarshalJSON()
}

call ct.Marshal(your layout)

If you have access to the package in which CustomTime exists go ahead and modify the CustomTime instance directly and make Marshal unexported if you want.

There isn't an automatic way to pass information from Entry to CustomTime's MarshalJSON method, not even using the struct tags. The only thing you can do, I believe, apart from creating a new type, is to add a new field to CustomTime and then, just before marshaling the Entry instance, manually set it to some value that will indicate how MarshalJSON should format the output. My suggestion would be to create a new type, a bit repetitive but cleaner.

Note that embedding allows you to avoid having to re-implement those methods that are supposed to behave the same in both, the embedded type and the embedding type. So, in your case, you only need to re-implement the json marshaling and unmarshaling methods. The isset, value, and scan methods don't have to be re-implemented.