s_cherry_e/sr/internal/extend/open_time/parser.go

package openTime

import (
	"errors"
	"fmt"
	"strings"
	"time"

	cherryString "github.com/cherry-game/cherry/extend/string"
	ctime "github.com/cherry-game/cherry/extend/time"
	cherryLogger "github.com/cherry-game/cherry/logger"
)

var parserMap = map[Type]Parser{
	OpenForever:          &foreverParser{},
	OpenDaily:            &dailyParser{},
	OpenWeeklyContinual:  &weeklyContinualParser{},
	OpenWeekly:           &weeklyParser{},
	OpenMonthlyContinual: &monthlyContinualParser{},
	OpenMonthly:          &monthlyParser{},
	OpenFixedRange:       &fixedRangeParser{},
	OpenPeriodic:         &periodicParser{},
}

type (
	// OpenTime 开启时间
	OpenTime interface {
		// Between 判断时间 t 是否在开启时间内
		Between(t *ctime.CherryTime) bool
		// TimeRange 返回开启时间 [startTime, endTime] 区间
		TimeRange(t *ctime.CherryTime) (ctime.CherryTime, ctime.CherryTime)
	}

	Parser interface {
		Parse(string) (OpenTime, error)
	}

	durationRange struct {
		startTime time.Duration
		endTime   time.Duration
	}

	timeRange struct {
		startTime ctime.CherryTime
		endTime   ctime.CherryTime
	}
)

// Parse 根据开启时间类型 typ 解析 params
func Parse(typ Type, params string) (OpenTime, error) {
	if parser, ok := parserMap[typ]; ok {
		return parser.Parse(params)
	}

	return nil, errors.New("unknown open time type")
}

// Parse 根据开启时间类型 typ 解析 params, 解析失败返回 DefaultOpenTime
func ParseDefault(typ Type, params string) OpenTime {
	parser, ok := parserMap[typ]
	if !ok {
		return DefaultOpenTime
	}

	open, err := parser.Parse(params)
	if err != nil {
		cherryLogger.Warnf("OpenTime parse failed: [type=%d, params=%s] %v", typ, params, err)
		return DefaultOpenTime
	}

	return open
}

// parseDuration HH:mm
func parseDuration(s string) (time.Duration, error) {
	hms := strings.Split(s, ":")
	var duration time.Duration
	hour, ok := cherryString.ToInt64(hms[0])
	if !ok {
		return 0, fmt.Errorf("nonsupport time string: %s", s)
	}

	duration += time.Duration(hour) * time.Hour

	if len(hms) >= 2 {
		mins, ok := cherryString.ToInt64(hms[1])
		if !ok {
			return 0, fmt.Errorf("nonsupport time string: %s", s)
		}

		duration += time.Duration(mins) * time.Minute
	}

	if len(hms) >= 3 {
		secs, ok := cherryString.ToInt64(hms[2])
		if !ok {
			return 0, fmt.Errorf("nonsupport time string: %s", s)
		}

		duration += time.Duration(secs) * time.Second
	}

	return duration, nil
}

// parseDateTime yyyyMMdd/HH:mm
func parseDateTime(str string) (t ctime.CherryTime, e error) {
	dt := strings.Split(str, "/")
	if len(dt) < 2 {
		e = fmt.Errorf("nonsupport params: %s", str)
		return
	}

	date, err := time.Parse("20060102", dt[0])
	if err != nil {
		e = err
		return
	}

	duration, err := parseDuration(dt[1])
	if err != nil {
		e = err
		return
	}

	t.Time = date.Add(duration)
	return t, nil
}