Function jobRowFromInternal

riverdriver/riversqlite/river_sqlite_driver.go:1564–1624

(internal *dbsqlc.RiverJob)

}

func jobRowFromInternal(internal *dbsqlc.RiverJob) (*rivertype.JobRow, error) {
	var attemptedAt *time.Time
	if internal.AttemptedAt != nil {
		t := internal.AttemptedAt.UTC()
		attemptedAt = &t
	}

	var attemptedBy []string
	if internal.AttemptedBy != nil {
		if err := json.Unmarshal(internal.AttemptedBy, &attemptedBy); err != nil {
			return nil, fmt.Errorf("error unmarshaling `attempted_by`: %w", err)
		}
	}

	var errors []rivertype.AttemptError
	if internal.Errors != nil {
		if err := json.Unmarshal(internal.Errors, &errors); err != nil {
			return nil, fmt.Errorf("error unmarshaling `errors`: %w", err)
		}
	}

	var finalizedAt *time.Time
	if internal.FinalizedAt != nil {
		t := internal.FinalizedAt.UTC()
		finalizedAt = &t
	}

	var tags []string
	if err := json.Unmarshal(internal.Tags, &tags); err != nil {
		return nil, fmt.Errorf("error unmarshaling `tags`: %w", err)
	}

	var uniqueStatesByte byte
	if internal.UniqueStates != nil {
		if *internal.UniqueStates < 0 || *internal.UniqueStates > 255 {
			return nil, fmt.Errorf("value out of range for byte: %d", *internal.UniqueStates)
		}
		uniqueStatesByte = byte(*internal.UniqueStates)
	}

	return &rivertype.JobRow{
		ID:           internal.ID,
		Attempt:      max(int(internal.Attempt), 0),
		AttemptedAt:  attemptedAt,
		AttemptedBy:  attemptedBy,
		CreatedAt:    internal.CreatedAt.UTC(),
		EncodedArgs:  internal.Args,
		Errors:       errors,
		FinalizedAt:  finalizedAt,
		Kind:         internal.Kind,
		MaxAttempts:  max(int(internal.MaxAttempts), 0),
		Metadata:     internal.Metadata,
		Priority:     max(int(internal.Priority), 0),
		Queue:        internal.Queue,
		ScheduledAt:  internal.ScheduledAt.UTC(),
		State:        rivertype.JobState(internal.State),
		Tags:         tags,
		UniqueKey:    internal.UniqueKey,