function generateRFC3339Helper()

in packages/codegen.go/src/time.ts [236:435]

• 129 lines of code
• 18 McCabe index (conditional complexity)

function generateRFC3339Helper(preamble: string, dateTime: boolean, time: boolean, needsPopulate: boolean): string {
  const imports = new ImportManager();
  imports.add('regexp');
  imports.add('strings');
  imports.add('time');
  if (needsPopulate) {
    imports.add('encoding/json');
    imports.add('fmt');
    imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore');
    imports.add('reflect');
  }
  let text = `${preamble}

${imports.text()}

// Azure reports time in UTC but it doesn't include the 'Z' time zone suffix in some cases.
var tzOffsetRegex = regexp.MustCompile(\`(?:Z|z|\\+|-)(?:\\d+:\\d+)*"*$\`)
`;

  if (dateTime) {
    text +=
`
const (
	utcDateTime        = "2006-01-02T15:04:05.999999999"
	utcDateTimeJSON    = \`"\` + utcDateTime + \`"\`
	utcDateTimeNoT     = "2006-01-02 15:04:05.999999999"
	utcDateTimeJSONNoT = \`"\` + utcDateTimeNoT + \`"\`
	dateTimeNoT        = \`2006-01-02 15:04:05.999999999Z07:00\`
	dateTimeJSON       = \`"\` + time.RFC3339Nano + \`"\`
	dateTimeJSONNoT    = \`"\` + dateTimeNoT + \`"\`
)

type dateTimeRFC3339 time.Time

func (t dateTimeRFC3339) MarshalJSON() ([]byte, error) {
	tt := time.Time(t)
	return tt.MarshalJSON()
}

func (t dateTimeRFC3339) MarshalText() ([]byte, error) {
	tt := time.Time(t)
	return tt.MarshalText()
}

func (t *dateTimeRFC3339) UnmarshalJSON(data []byte) error {
	tzOffset := tzOffsetRegex.Match(data)
	hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t")
	var layout string
	if tzOffset && hasT {
		layout = dateTimeJSON
	} else if tzOffset {
		layout = dateTimeJSONNoT
	} else if hasT {
		layout = utcDateTimeJSON
	} else {
		layout = utcDateTimeJSONNoT
	}
	return t.Parse(layout, string(data))
}

func (t *dateTimeRFC3339) UnmarshalText(data []byte) error {
	if len(data) == 0 {
		return nil
	}
	tzOffset := tzOffsetRegex.Match(data)
	hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t")
	var layout string
	if tzOffset && hasT {
		layout = time.RFC3339Nano
	} else if tzOffset {
		layout = dateTimeNoT
	} else if hasT {
		layout = utcDateTime
	} else {
		layout = utcDateTimeNoT
	}
	return t.Parse(layout, string(data))
}

func (t *dateTimeRFC3339) Parse(layout, value string) error {
	p, err := time.Parse(layout, strings.ToUpper(value))
	*t = dateTimeRFC3339(p)
	return err
}

func (t dateTimeRFC3339) String() string {
	return time.Time(t).Format(time.RFC3339Nano)
}
`;
    if (needsPopulate) {
      text +=
`

func populateDateTimeRFC3339(m map[string]any, k string, t *time.Time) {
	if t == nil {
		return
	} else if azcore.IsNullValue(t) {
		m[k] = nil
		return
	} else if reflect.ValueOf(t).IsNil() {
		return
	}
	m[k] = (*dateTimeRFC3339)(t)
}

func unpopulateDateTimeRFC3339(data json.RawMessage, fn string, t **time.Time) error {
	if data == nil || string(data) == "null" {
		return nil
	}
	var aux dateTimeRFC3339
	if err := json.Unmarshal(data, &aux); err != nil {
		return fmt.Errorf("struct field %s: %v", fn, err)
	}
	*t = (*time.Time)(&aux)
	return nil
}
`;
    }
  }

  if (time) {
    text += `
const (
	utcTimeJSON = \`"15:04:05.999999999"\`
	utcTime     = "15:04:05.999999999"
	timeFormat  = "15:04:05.999999999Z07:00"
)

type timeRFC3339 time.Time

func (t timeRFC3339) MarshalJSON() ([]byte, error) {
	s, _ := t.MarshalText()
	return []byte(fmt.Sprintf("\\"%s\\"", s)), nil
}

func (t timeRFC3339) MarshalText() ([]byte, error) {
	tt := time.Time(t)
	return []byte(tt.Format(timeFormat)), nil
}

func (t *timeRFC3339) UnmarshalJSON(data []byte) error {
	layout := utcTimeJSON
	if tzOffsetRegex.Match(data) {
		layout = timeFormat
	}
	return t.Parse(layout, string(data))
}

func (t *timeRFC3339) UnmarshalText(data []byte) error {
	if len(data) == 0 {
		return nil
	}
	layout := utcTime
	if tzOffsetRegex.Match(data) {
		layout = timeFormat
	}
	return t.Parse(layout, string(data))
}

func (t *timeRFC3339) Parse(layout, value string) error {
	p, err := time.Parse(layout, strings.ToUpper(value))
	*t = timeRFC3339(p)
	return err
}

func (t timeRFC3339) String() string {
	tt := time.Time(t)
	return tt.Format(timeFormat)
}
`;
    if (needsPopulate) {
      text += `
func populateTimeRFC3339(m map[string]any, k string, t *time.Time) {
	if t == nil {
		return
	} else if azcore.IsNullValue(t) {
		m[k] = nil
		return
	} else if reflect.ValueOf(t).IsNil() {
		return
	}
	m[k] = (*timeRFC3339)(t)
}

func unpopulateTimeRFC3339(data json.RawMessage, fn string, t **time.Time) error {
	if data == nil || string(data) == "null" {
		return nil
	}
	var aux timeRFC3339
	if err := json.Unmarshal(data, &aux); err != nil {
		return fmt.Errorf("struct field %s: %v", fn, err)
	}
	*t = (*time.Time)(&aux)
	return nil
}
`;
    }
  }
  return text;
}