package main
import (
"fmt"
"sort"
"strconv"
"strings"
"time"
)
const (
FORMAT_DATETIME = "2006-01-02 15:04:05"
FORMAT_DURATION = "15h04m05s"
)
// the frequency an event recurs
type RecurrenceWeekday string
// the frequency an event recurs
type RecurrenceFrequency string
const (
SecondRecurrenceFrequency RecurrenceFrequency = "SECONDLY"
MinuteRecurrenceFrequency = "MINUTELY"
HourRecurrenceFrequency = "HOURLY"
DayRecurrenceFrequency = "DAILY"
WeekRecurrenceFrequency = "WEEKLY"
MonthRecurrenceFrequency = "MONTHLY"
YearRecurrenceFrequency = "YEARLY"
)
const (
MondayRecurrenceWeekday RecurrenceWeekday = "MO"
TuesdayRecurrenceWeekday = "TU"
WednesdayRecurrenceWeekday = "WE"
ThursdayRecurrenceWeekday = "TH"
FridayRecurrenceWeekday = "FR"
SaturdayRecurrenceWeekday = "SA"
SundayRecurrenceWeekday = "SU"
)
func Date(year int, month time.Month, monthWeek int, weekDay time.Weekday, hour, minute, sec int, loc *time.Location) time.Time {
monthFstDayTime := time.Date(year, month, 1, hour, minute, sec, 0, loc) //一号
week := monthFstDayTime.Weekday()
var monthDay int = 1
if week != time.Sunday { // 算出第一个星期天到底是几号
monthDay = 1 + int(time.Sunday) - int(week)
//monthDay = int(week) - 7
}
if week == time.Sunday {
monthDay = -6
}
monthDay = monthDay + (monthWeek * 7) + int(weekDay)
return time.Date(year, month, monthDay, hour, minute, sec, 0, loc)
}
func WeekdayInt(s string) time.Weekday {
var r time.Weekday
switch RecurrenceWeekday(s) {
case SundayRecurrenceWeekday:
r = time.Sunday
case MondayRecurrenceWeekday:
r = time.Monday
case TuesdayRecurrenceWeekday:
r = time.Tuesday
case WednesdayRecurrenceWeekday:
r = time.Wednesday
case ThursdayRecurrenceWeekday:
r = time.Thursday
case FridayRecurrenceWeekday:
r = time.Friday
case SaturdayRecurrenceWeekday:
r = time.Saturday
}
return r
}
func WeekdayString(weekday time.Weekday) RecurrenceWeekday {
var r RecurrenceWeekday
switch weekday {
case time.Sunday:
r = SundayRecurrenceWeekday
case time.Monday:
r = MondayRecurrenceWeekday
case time.Tuesday:
r = TuesdayRecurrenceWeekday
case time.Wednesday:
r = WednesdayRecurrenceWeekday
case time.Thursday:
r = ThursdayRecurrenceWeekday
case time.Friday:
r = FridayRecurrenceWeekday
case time.Saturday:
return SaturdayRecurrenceWeekday
}
return r
}
type TRecurrenceInfo struct {
EventId uint64 `json:"-"`
Frequency string `json:"frequency,omitempty"` // daily, weekly, monthly, yearly
Interval int64 `json:"interval,omitempty"` // 每几天(1-365)/周(1-52)/月(1-12)/年(1-10)
ByDay string `json:"byday,omitempty"` // 星期几(SU,MO,TU,WE,TH,FR,SA), CSV格式字符串, 所以存在可能为多个
ByMonth string `json:"bymonth,omitempty"` // 几月(1-12)
ByMonthDay string `json:"bymonthday,omitempty"` // 几号(1-31)
BySetPos string `json:"bysetpos,omitempty"` // 第几周(1-5)
RecurrenceCount int64 `json:"repeatcount,omitempty"` // 循环次数(2-100)
RecurrenceEndDate int64 `json:"repeatenddate,omitempty"` // 时间戳(秒)
}
const (
DayDuration = int64(time.Hour) * 24
WeekDuration = int64(time.Hour) * 24 * 7
MonthDuration = int64(time.Hour) * 24 * 30
YearDuration = int64(time.Hour) * 24 * 365
)
//周期会议的第一场时间
func (rule *TRecurrenceInfo) GetFstTime(start, end, length int64, loc *time.Location) (fstStart, fstEnd time.Time) {
startTime := time.Unix(start, 0).In(loc)
eneTime := time.Unix(end, 0).In(loc)
switch strings.ToUpper(rule.Frequency) {
case DayRecurrenceFrequency:
fstStart = startTime
fstEnd = eneTime
case WeekRecurrenceFrequency:
if len(rule.ByDay) > 0 {
dayWeekInts := rule.convertDayList()
fstWeekDay := time.Weekday(dayWeekInts[0])
startWeekDay := startTime.Weekday()
if startWeekDay == fstWeekDay {
fstStart = startTime
fstEnd = fstStart.Add(time.Duration(int64(time.Hour) * length))
} else {
deleduration := int64(7-startWeekDay+fstWeekDay) * DayDuration
fstStart = startTime.Add(time.Duration(deleduration))
fstEnd = fstStart.Add(time.Duration(int64(time.Hour) * length))
}
}
case MonthRecurrenceFrequency:
year, month, _ := startTime.Date()
hour, minute, sec := startTime.Clock()
if len(rule.ByMonthDay) > 0 {
monthDayList := strings.Split(rule.ByMonthDay, ",")
fstMonthDay := 1
if len(monthDayList) > 0 {
fstMonthDay = int(ToInt64(monthDayList[0], 1))
}
fstStart = time.Date(year, month, fstMonthDay, hour, minute, sec, 0, loc)
if fstStart.Unix() < start {
fstStart = time.Date(year, month+1, fstMonthDay, hour, minute, sec, 0, loc)
}
fstEnd = fstStart.Add(time.Duration(int64(time.Hour) * length))
}
if len(rule.BySetPos) > 0 && len(rule.ByDay) > 0 {
fstWeekDay := WeekdayInt(rule.ByDay)
fstStart = Date(year, month, int(ToInt64(rule.BySetPos, 0)),
fstWeekDay, hour, minute, sec, loc)
if fstStart.Unix() < start {
fstStart = Date(year, month+1, int(ToInt64(rule.BySetPos, 0)),
fstWeekDay, hour, minute, sec, loc)
}
fstEnd = fstStart.Add(time.Duration(int64(time.Hour) * length))
}
case YearRecurrenceFrequency:
year, month, _ := startTime.Date()
hour, minute, sec := startTime.Clock()
month = time.Month(ToInt64(rule.ByMonth, 1))
if len(rule.ByMonthDay) > 0 {
fstStart = time.Date(year, month, int(ToInt64(rule.ByMonthDay, 1)), hour, minute, sec, 0, loc)
if fstStart.Unix() < start {
fstStart = time.Date(year+1, month, int(ToInt64(rule.ByMonthDay, 1)), hour, minute, sec, 0, loc)
}
fstEnd = fstStart.Add(time.Duration(int64(time.Hour) * length))
}
if len(rule.BySetPos) > 0 && len(rule.ByDay) > 0 {
fstWeekDay := WeekdayInt(rule.ByDay)
fstStart = Date(year, month, int(ToInt64(rule.BySetPos, 0)),
fstWeekDay, hour, minute, sec, loc)
if fstStart.Unix() < start {
fstStart = Date(year+1, month, int(ToInt64(rule.BySetPos, 0)),
fstWeekDay, hour, minute, sec, loc)
}
fstEnd = fstStart.Add(time.Duration(int64(time.Hour) * length))
}
}
return
}
//利用迭代的方式做
//@index 表示第几个周期
//@fstStartTime 周期第一场的时间
//@fstEndTime 周期第一场的结束时间
func (rule *TRecurrenceInfo) GetRecurrenceSingleTime2(index, fstStartTime, fstEndTime, now int64, loc *time.Location) (start, end time.Time) {
if index < 0 {
return
}
// 处理周期会议
var deltaDuration int64 = 0
if rule.RecurrenceCount > 0 {
if index >= rule.RecurrenceCount {
return
}
}
if now <= fstStartTime {
return
}
start = time.Unix(fstStartTime, 0).In(loc)
end = time.Unix(fstEndTime, 0).In(loc)
interval := rule.Interval
switch strings.ToUpper(rule.Frequency) {
case DayRecurrenceFrequency:
deltaDuration = index * interval * DayDuration
start = start.Add(time.Duration(deltaDuration))
end = end.Add(time.Duration(deltaDuration))
if now > end.Unix() {
index++
return rule.GetRecurrenceSingleTime2(index, fstStartTime, fstEndTime, now, loc)
}
case WeekRecurrenceFrequency:
dayList := strings.Split(rule.ByDay, ",")
dayLen := int64(len(dayList))
if dayLen > 1 {
dayWeekInts := rule.convertDayList()
offset := dayWeekInts[len(dayWeekInts)-1] - dayWeekInts[0]
//计算这个周期里的第一天的开始与最后一天时间结束时间
fstDayStartTime, _, _, lastDayEndTime := rule.singleCycleWeekTime(index, interval, offset, start, end)
fmt.Println("recurrenceSingleStartTime:", fstDayStartTime, "recurrenceSingleEndTime:", lastDayEndTime, "offset:", offset, "now:", time.Unix(now, 0).In(loc))
//如果当前时间大于某个周期的最后一天的时间，则递归，继续计算下个周期的时间
if now > lastDayEndTime.Unix() {
index++
return rule.GetRecurrenceSingleTime2(index, fstStartTime, fstEndTime, now, loc)
}
//否则，在这个周期里查找最近的一天的时间
if now < lastDayEndTime.Unix() {
nowTime := time.Unix(now, 0).In(loc)
nowWeekDay := nowTime.Weekday()
if nowWeekDay == 0 {
nowWeekDay = 7
}
//否则的话，就取下个周期中，比当前时间所在天最近的一天
for _, dayWeekInt := range dayWeekInts {
if nowWeekDay <= time.Weekday(dayWeekInt) {
offset = dayWeekInt - dayWeekInts[0]
break
}
}
if now < fstDayStartTime.Unix() {
offset = 0
}
_, _, start, end = rule.singleCycleWeekTime(index, interval, offset, start, end)
fmt.Println("************************")
fmt.Println("start:", start, "end:", end)
return
}
break
}
_, _, start, end = rule.singleCycleWeekTime(index, interval, 0, start, end)
if now > end.Unix() {
index++
return rule.GetRecurrenceSingleTime2(index, fstStartTime, fstEndTime, now, loc)
}
case MonthRecurrenceFrequency:
if rule.BySetPos == "" {
dayList := strings.Split(rule.ByMonthDay, ",")
dayLen := int64(len(dayList))
var offset int64
if dayLen > 0 {
offset = ToInt64(dayList[dayLen-1], 0) - ToInt64(dayList[0], 0)
}
fstDayStartTime, _, _, lastDayEndTime := rule.singleCycleMonthTime(index, interval, offset, rule.BySetPos, start, end)
fmt.Println("recurrenceSingleStartTime:", fstDayStartTime, "recurrenceSingleEndTime:", lastDayEndTime, "offset:", offset)
if now > lastDayEndTime.Unix() {
index++
return rule.GetRecurrenceSingleTime2(index, fstStartTime, fstEndTime, now, loc)
}
//查找大于当前时间且在周期规则内的时间
if now < lastDayEndTime.Unix() {
nowTime := time.Unix(now, 0).In(loc)
_, _, nowDayInt := nowTime.Date()
//当前时间比下一个周期的开始时间早，则去下一个周期的开始时间
if now < fstDayStartTime.Unix() {
offset = 0
}
//否则的话，就取下个周期中，比当前时间所在天最近的一天
for _, dayInt := range dayList {
if int64(nowDayInt) <= ToInt64(dayInt, 0) {
offset = ToInt64(dayInt, 0) - ToInt64(dayList[0], 0)
break
}
}
_, _, start, end = rule.singleCycleMonthTime(index, interval, offset, rule.BySetPos, start, end)
fmt.Println("month")
fmt.Println("start:", start, "end:", end)
return
}
} else {
_, _, start, end = rule.singleCycleMonthTime(index, interval, 0, rule.BySetPos, start, end)
if now > end.Unix() {
index++
return rule.GetRecurrenceSingleTime2(index, fstStartTime, fstEndTime, now, loc)
}
}
case YearRecurrenceFrequency:
if rule.BySetPos == "" {
nextYearTime := start.AddDate(int(index*interval), 0, 0)
deltaDuration = int64(nextYearTime.Sub(start))
start = start.Add(time.Duration(deltaDuration))
end = end.Add(time.Duration(deltaDuration))
} else {
bySetPos := ToInt64(rule.BySetPos, 1)
year, month, _ := start.Date()
hour, minute, sec := start.Clock()
start = Date(year+int(index*interval), month, int(bySetPos),
WeekdayInt(rule.ByDay), hour, minute, sec, start.Location())
year, month, _ = end.Date()
hour, minute, sec = end.Clock()
end = Date(year+int(index*interval), month, int(bySetPos),
WeekdayInt(rule.ByDay), hour, minute, sec, end.Location())
}
if now > end.Unix() {
index++
return rule.GetRecurrenceSingleTime2(index, fstStartTime, fstEndTime, now, loc)
}
}
return
}
//返回某个周期的会议的开始、结束时间
//这种case:每周礼拜一、二、五周期会议,会返回第一天的开始、结束（比如：礼拜一）和最后一天的开始、结束时间（比如：礼拜五）
//@index表示第几个周期
//@interval表示周期间隔
//@offset表示某个周期里，最后一天与第一天的时间间隔。比如，这种case:周五和周一的时间间隔
//@fstStart表示周期会议第一场开始时间
//@fstEnd表示周期会议第一场结束时间
//@fstDayStartTime表示某个周期里，第一天的开始时间
//@fstDayEndTime表示某个周期里，第一天的结束时间
//@start某个周期里固定某天的会议开始时间，当offset=0时，等于fstDayStartTime
//@end某个周期里固定某天的会议结束时间,当offset=0时，等于fstDayEndTime
func (rule *TRecurrenceInfo) singleCycleWeekTime(index, interval int64, offset int, fstStart, fstEnd time.Time) (fstDayStartTime, fstDayEndTime, start, end time.Time) {
deltaDuration := index * interval * WeekDuration
fstDayStartTime = fstStart.Add(time.Duration(deltaDuration))
fstDayEndTime = fstEnd.Add(time.Duration(deltaDuration))
deltaDuration += int64(offset) * DayDuration
start = fstStart.Add(time.Duration(deltaDuration))
end = fstEnd.Add(time.Duration(deltaDuration))
return
}
//返回某个周期的会议的开始、结束时间
//这种case:每月2、3、4、5号周期会议,会返回第一天的开始、结束（比如：2号）和最后一天的开始、结束时间（比如：5号）
//@index表示第几个周期
//@offset表示某个周期里，最后一天与第一天的时间间隔。比如，这种case:周五和周一的时间间隔
//@fstStart表示周期会议第一场开始时间
//@fstEnd表示周期会议第一场结束时间
//@fstDayStartTime表示某个周期里，第一天的开始时间
//@fstDayEndTime表示某个周期里，第一天的结束时间
//@start某个周期里固定某天的会议开始时间，当offset=0时，等于fstDayStartTime
//@end某个周期里固定某天的会议结束时间,当offset=0时，等于fstDayEndTime
func (rule *TRecurrenceInfo) singleCycleMonthTime(index, interval, offset int64, setPos string, fstStart, fstEnd time.Time) (fstDayStartTime, fstDayEndTime, start, end time.Time) {
nextMonthTime := start.AddDate(0, int(index*interval), 0)
deltaDuration := int64(nextMonthTime.Sub(start))
fstDayStartTime = fstStart.Add(time.Duration(deltaDuration))
fstDayEndTime = fstEnd.Add(time.Duration(deltaDuration))
deltaDuration += int64(offset) * DayDuration
start = fstStart.Add(time.Duration(deltaDuration))
end = fstEnd.Add(time.Duration(deltaDuration))
if len(setPos) != 0 {
bySetPos := ToInt64(rule.BySetPos, 1)
year, month, _ := fstStart.Date()
hour, minute, sec := fstStart.Clock()
start = Date(year, month+time.Month(index*interval), int(bySetPos),
WeekdayInt(rule.ByDay), hour, minute, sec, start.Location())
fstDayEndTime = start
year, month, _ = fstEnd.Date()
hour, minute, sec = fstEnd.Clock()
end = Date(year, month+time.Month(index*interval), int(bySetPos),
WeekdayInt(rule.ByDay), hour, minute, sec, end.Location())
fstDayEndTime = end
}
return
}
func (rule *TRecurrenceInfo) convertDayList() []int {
dayList := strings.Split(rule.ByDay, ",")
dayWeekInts := make([]int, 0)
for _, day := range dayList {
dayWeekInt := int(WeekdayInt(day))
if dayWeekInt == 0 {
dayWeekInt = 7
}
dayWeekInts = append(dayWeekInts, dayWeekInt)
}
sort.Ints(dayWeekInts)
return dayWeekInts
}
//落在周期规则时间里这一天和第一天所在周几相隔的天数
func getDuration(dayList []string, recentWeekDayInt int64) int64 {
firstWeekDayInt := int64(WeekdayInt(dayList[0]))
return recentWeekDayInt - firstWeekDayInt
}
func ToInt64(v interface{}, defaultVal int64) int64 {
if v == nil {
return defaultVal
}
switch v.(type) {
case bool:
if v.(bool) {
return 1
}
return 0
case string:
i, err := strconv.ParseInt(v.(string), 10, 64)
if err != nil {
return defaultVal
}
return i
case uint64:
return int64(v.(uint64))
case int64:
return int64(v.(int64))
case int:
return int64(v.(int))
case int32:
return int64(v.(int32))
case uint32:
return int64(v.(uint32))
case float64:
return int64(v.(float64))
case int8:
return int64(v.(int8))
case uint8:
return int64(v.(uint8))
}
return defaultVal
}
func main() {
rule := &TRecurrenceInfo{
Frequency: "daily",
Interval: 1,
RecurrenceEndDate: 0,
}
rule = &TRecurrenceInfo{
Frequency: "daily",
Interval: 2,
RecurrenceEndDate: 0,
}
rule = &TRecurrenceInfo{
Frequency: "weekly",
Interval: 1,
ByDay: "MO,TU,WE,TH,FR",
RecurrenceEndDate: 0,
}
rule = &TRecurrenceInfo{
Frequency: "weekly",
Interval: 1,
ByDay: "MO,WE,FR",
RecurrenceEndDate: 0,
}
rule = &TRecurrenceInfo{
Frequency: "weekly",
Interval: 2,
ByDay: "MO,WE,FR",
RecurrenceEndDate: 0,
}
rule = &TRecurrenceInfo{
Frequency: "weekly",
Interval: 2,
ByDay: "MO,WE,FR",
RecurrenceEndDate: 0,
}
nowStr := "2022-08-09 10:00:00"
startStr := "2022-08-01 10:00:00"
endStr := "2022-08-01 11:00:00"
now, _ := time.Parse(FORMAT_DATETIME, nowStr)
start, _ := time.Parse(FORMAT_DATETIME, startStr)
end, _ := time.Parse(FORMAT_DATETIME, endStr)
fmt.Println("now:", now.Unix(), "start:", start.Unix())
s, e := rule.GetRecurrenceSingleTime2(0, start.Unix(), end.Unix(), now.Unix(), time.Local)
fmt.Println("【周N周后M+天每几周星期几】递归的方式获取周期单场时间：start,end", s, e)
rule = &TRecurrenceInfo{
Frequency: "weekly",
Interval: 2,
ByDay: "MO",
RecurrenceEndDate: 0,
}
nowStr = "2022-08-09 10:00:00"
startStr = "2022-08-01 10:00:00"
endStr = "2022-08-01 11:00:00"
now, _ = time.Parse(FORMAT_DATETIME, nowStr)
start, _ = time.Parse(FORMAT_DATETIME, startStr)
end, _ = time.Parse(FORMAT_DATETIME, endStr)
fmt.Println("now:", now.Unix(), "start:", start.Unix())
s, e = rule.GetRecurrenceSingleTime2(0, start.Unix(), end.Unix(), now.Unix(), time.Local)
fmt.Println("【周】递归的方式获取周期单场时间：start,end", s, e)
rule = &TRecurrenceInfo{
Frequency: "monthly",
Interval: 1,
ByMonthDay: "1,2,3,4,5,8,18",
RecurrenceEndDate: 0,
}
nowStr = "2022-08-09 10:00:00"
startStr = "2022-08-01 10:00:00"
endStr = "2022-08-01 11:00:00"
now, _ = time.Parse(FORMAT_DATETIME, nowStr)
start, _ = time.Parse(FORMAT_DATETIME, startStr)
end, _ = time.Parse(FORMAT_DATETIME, endStr)
s, e = rule.GetRecurrenceSingleTime2(0, start.Unix(), end.Unix(), now.Unix(), time.Local)
fmt.Println("【月每几月的几号】递归的方式获取周期单场时间：start,end", s, e)
rule = &TRecurrenceInfo{
Frequency: "monthly",
Interval: 1,
ByDay: "MO",
BySetPos: "2",
RecurrenceEndDate: 0,
}
nowStr = "2022-08-09 10:00:00"
startStr = "2022-08-08 10:00:00"
endStr = "2022-08-08 11:00:00"
now, _ = time.Parse(FORMAT_DATETIME, nowStr)
start, _ = time.Parse(FORMAT_DATETIME, startStr)
end, _ = time.Parse(FORMAT_DATETIME, endStr)
s, e = rule.GetRecurrenceSingleTime2(0, start.Unix(), end.Unix(), now.Unix(), time.Local)
fmt.Println("【月每几月的第几个星期几】递归的方式获取周期单场时间：start,end", s, e)
// recentDay, recentWeekDayInt, recentDayInt := recentDay(now.Unix(), []string{"MO", "WE", "FR"}, time.Local)
// fmt.Println("**************")
// fmt.Println(recentDay, recentWeekDayInt, recentDayInt)
getFstTime()
}
func getFstTime() {
rule := &TRecurrenceInfo{
Frequency: "daily",
Interval: 2,
RecurrenceEndDate: 0,
}
startStr := "2022-08-11 10:00:00"
endStr := "2022-08-11 11:00:00"
start, _ := time.Parse(FORMAT_DATETIME, startStr)
end, _ := time.Parse(FORMAT_DATETIME, endStr)
fstStart, fstEnd := rule.GetFstTime(start.Unix(), end.Unix(), 1, time.Local)
fmt.Println("【每两天】", fstStart, fstEnd)
rule = &TRecurrenceInfo{
Frequency: "weekly",
Interval: 1,
ByDay: "MO,TU,WE,TH,FR",
RecurrenceEndDate: 0,
}
fstStart, fstEnd = rule.GetFstTime(start.Unix(), end.Unix(), 1, time.Local)
fmt.Println("【每周一二三四五】", fstStart, fstEnd)
rule = &TRecurrenceInfo{
Frequency: "weekly",
Interval: 1,
ByDay: "TH",
RecurrenceEndDate: 0,
}
fstStart, fstEnd = rule.GetFstTime(start.Unix(), end.Unix(), 1, time.Local)
fmt.Println("【每周四】", fstStart, fstEnd)
rule = &TRecurrenceInfo{
Frequency: "monthly",
Interval: 1,
ByMonthDay: "1,2,3,4,5,8,18",
RecurrenceEndDate: 0,
}
fstStart, fstEnd = rule.GetFstTime(start.Unix(), end.Unix(), 1, time.Local)
fmt.Println("【月每几月的几号】", fstStart, fstEnd)
rule = &TRecurrenceInfo{
Frequency: "monthly",
Interval: 1,
ByDay: "MO",
BySetPos: "2",
RecurrenceEndDate: 0,
}
fstStart, fstEnd = rule.GetFstTime(start.Unix(), end.Unix(), 1, time.Local)
fmt.Println("【月每几月的第几个星期几】", fstStart, fstEnd)
rule = &TRecurrenceInfo{
Frequency: "yearly",
Interval: 1,
ByMonth: "1",
ByMonthDay: "1",
RecurrenceEndDate: 0,
}
fstStart, fstEnd = rule.GetFstTime(start.Unix(), end.Unix(), 1, time.Local)
fmt.Println("【每年第一个月1号】", fstStart, fstEnd)
rule = &TRecurrenceInfo{
Frequency: "yearly",
Interval: 1,
ByMonth: "1",
BySetPos: "1",
ByDay: "MO",
RecurrenceEndDate: 0,
}
fstStart, fstEnd = rule.GetFstTime(start.Unix(), end.Unix(), 1, time.Local)
fmt.Println("【每年第一个月第一周礼拜一】", fstStart, fstEnd)
}
周期时间计算方法
于 2022-08-23 17:29:56 首次发布
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
