timetable-mgr/vstp/convert.go

package vstp

import (
	"errors"
	"strings"

	"git.fjla.uk/owlboard/go-types/pkg/upstreamApi"
	"git.fjla.uk/owlboard/timetable-mgr/log"
)

// Simple type conversion
func convertCifType(in *upstreamApi.VSTPSchedule) (error, *upstreamApi.JsonScheduleV1) {
	if in == nil {
		return errors.New("input is nil"), nil
	}

	out := &upstreamApi.JsonScheduleV1{
		TransactionType:       in.TransactionType,
		CifBankHolidayRunning: in.CifBankHolidayRunning,
		CifStpIndicator:       in.CifStpIndicator,
		CifTrainUid:           in.CifTrainUid,
		ApplicableTimetable:   in.ApplicableTimetable,
		ScheduleDaysRun:       in.ScheduleDaysRun,
		ScheduleStartDate:     in.ScheduleStartDate,
		ScheduleEndDate:       in.ScheduleEndDate,
	}

	if len(in.ScheduleSegment) > 0 {
		if len(in.ScheduleSegment) > 1 {
			log.Warn("More than one element in schedule segment")
		}
		out.ScheduleSegment = convertSchedule(&in.ScheduleSegment[0])
		if trim(in.ScheduleSegment[0].AtocCode) != "" {
			out.AtocCode = in.ScheduleSegment[0].AtocCode
		} else {
			out.AtocCode = "UK"
		}
		return nil, out
	} else {
		log.Warn("VSTP Schedule Segment empty")
		return errors.New("schedule segment empty"), nil
	}
}

func convertSchedule(in *upstreamApi.VSTPScheduleSegment) upstreamApi.CifScheduleSegment {
	out := upstreamApi.CifScheduleSegment{
		SignallingId:                in.SignallingId,
		CifTrainCategory:            in.CifTrainCategory,
		CifHeadcode:                 in.CifHeadcode,
		CifTrainServiceCode:         in.CifTrainServiceCode,
		CifBusinessSector:           in.CifBusinessSector,
		CifPowerType:                in.CifPowerType,
		CifTimingLoad:               in.CifTimingLoad,
		CifSpeed:                    in.CifSpeed,
		CifOperatingCharacteristics: in.CifOperatingCharacteristics,
		CifTrainClass:               in.CifTrainClass,
		CifSleepers:                 in.CifSleepers,
		CifReservations:             in.CifReservations,
		CifCateringCode:             in.CifCateringCode,
		ScheduleLocation:            *convertLocations(&in.ScheduleLocation),
	}

	return out
}

func convertLocations(in *[]upstreamApi.VSTPScheduleLocation) *[]upstreamApi.CifScheduleLocation {
	if in == nil {
		log.Error("Input is nil")
		return nil
	}

	cifLocations := make([]upstreamApi.CifScheduleLocation, len(*in))

	for i, loc := range *in {
		cifLoc := upstreamApi.CifScheduleLocation{
			TiplocCode:           trim(loc.Location.Tiploc.TiplocId),
			Arrival:              convertTime(trim(loc.Arrival)),
			PublicArrival:        convertTime(trim(loc.PublicArrival)),
			Departure:            convertTime(trim(loc.Departure)),
			PublicDeparture:      convertTime(trim(loc.PublicDeparture)),
			Pass:                 convertTime(trim(loc.Pass)),
			Path:                 trim(loc.Path),
			Platform:             trim(loc.Platform),
			EngineeringAllowance: trim(loc.EngineeringAllowance),
			PathingAllowance:     trim(loc.PathingAllowance),
			PerformanceAllowance: trim(loc.PerformanceAllowance),
		}

		cifLocations[i] = cifLoc
	}

	return &cifLocations
}

func convertTime(in string) string {
	if len(in) < 4 {
		return in
	}
	return in[:4]
}

func trim(s string) string {
	return strings.TrimSpace(s)
}