func (self Weekday) NextAfter(t time.Time) (time.Time, error) {
diff := int(self) - int(t.Weekday())
if diff <= 0 {
diff += 7
}
return t.AddDate(0, 0, diff), nil
}
func main() {
log.Print("Started running timer")
var numberOfHours int
var message string
isWeekend := false
var currentTime time.Time
for {
numberOfHours += 1
currentTime = time.Now()
today := currentTime.Weekday()
hour := currentTime.Hour()
isWeekend = today == time.Sunday || today == time.Friday || today == time.Saturday
switch {
case (hour >= 22 || hour <= 3) && !isWeekend:
message = "Late night on a weekday. Sleep!."
case numberOfHours == 1:
message = "One hour! Take a break"
case numberOfHours == 2:
message = "Two hours! Take a break now."
case numberOfHours > 2: // or default:
message = "Take a break now. Seriously."
}
log.Print("Sleeping program for one hour")
time.Sleep(1 * time.Hour)
showNotification(message)
}
}
// Just like SUBMIT_JOB_BG, but run job at given time instead of
// immediately. This is not currently used and may be removed.
//
// Arguments:
// - NULL byte terminated function name.
// - NULL byte terminated unique ID.
// - NULL byte terminated minute (0-59).
// - NULL byte terminated hour (0-23).
// - NULL byte terminated day of month (1-31).
// - NULL byte terminated month (1-12).
// - NULL byte terminated day of week (0-6, 0 = Monday).
// - Opaque data that is given to the function as an argument.
func (c *Client) SubmitScheduledJob(func_name, uniq string, t time.Time, data []byte) error {
weekday := int(t.Weekday())
// go week day number starts at 0 on Sunday,
// gearman starts at 0 on Monday
if weekday == 0 {
weekday = 7
}
weekday -= 1
buf := new(bytes.Buffer)
buf.WriteString(func_name)
buf.WriteByte(0)
buf.WriteString(uniq)
buf.WriteByte(0)
buf.WriteString(strconv.Itoa(t.Minute()))
buf.WriteByte(0)
buf.WriteString(strconv.Itoa(t.Hour()))
buf.WriteByte(0)
buf.WriteString(strconv.Itoa(t.Day()))
buf.WriteByte(0)
buf.WriteString(strconv.Itoa(int(t.Month())))
buf.WriteByte(0)
buf.WriteString(strconv.Itoa(weekday))
buf.WriteByte(0)
buf.Write(data)
return c.server.Send(CS_SUBMIT_JOB_EPOCH, buf.Bytes())
}
// Returns wheter the Timing is active at the specified time
func (rit *RITiming) IsActiveAt(t time.Time) bool {
// check for years
if len(rit.Years) > 0 && !rit.Years.Contains(t.Year()) {
return false
}
// check for months
if len(rit.Months) > 0 && !rit.Months.Contains(t.Month()) {
return false
}
// check for month days
if len(rit.MonthDays) > 0 && !rit.MonthDays.Contains(t.Day()) {
return false
}
// check for weekdays
if len(rit.WeekDays) > 0 && !rit.WeekDays.Contains(t.Weekday()) {
return false
}
//log.Print("Time: ", t)
//log.Print("Left Margin: ", rit.getLeftMargin(t))
// check for start hour
if t.Before(rit.getLeftMargin(t)) {
return false
}
//log.Print("Right Margin: ", rit.getRightMargin(t))
// check for end hour
if t.After(rit.getRightMargin(t)) {
return false
}
return true
}
// func (c *Calendar) ValidOn(date string) bool {
// if stringDayDateComp(c.StartDate, date) <= 0 && stringDayDateComp(c.EndDate, date) >= 0 {
func (c *Calendar) ValidOn(intday int, t *time.Time) bool {
if c.StartDate <= intday && c.EndDate >= intday {
switch t.Weekday() {
case time.Monday:
return c.Monday
case time.Tuesday:
return c.Tuesday
case time.Wednesday:
return c.Wednesday
case time.Thursday:
return c.Thursday
case time.Friday:
return c.Friday
case time.Saturday:
return c.Saturday
case time.Sunday:
return c.Sunday
default:
return false
}
}
return false
}
func (source mondayAfternoons) GetBetween(start, end time.Time) ([]book.Booking, error) {
// find next monday
y, m, d := start.Date()
daysUntilMonday := int((7 + time.Monday - start.Weekday()) % 7)
nextmonday := time.Date(y, m, d+daysUntilMonday, 0, 0, 0, 0, start.Location())
// build a map of booked dates
bookedSet := make(map[time.Time]bool)
if booked, err := source.session.List(); err != nil {
return nil, err
} else {
for _, appointment := range booked {
y, m, d = appointment.Timestamp.Date()
date := time.Date(y, m, d, 0, 0, 0, 0, start.Location())
bookedSet[date] = true
}
}
// add a week at a time
var bookings []book.Booking
for !nextmonday.After(end) {
// take days where nothing has been booked yet
if _, exists := bookedSet[nextmonday]; !exists {
bookings = append(bookings, lizafternoon{nextmonday})
}
nextmonday = nextmonday.AddDate(0, 0, 7)
}
return bookings, nil
}
// repl replaces % directives with right time, will panic on unknown directive
func repl(match string, t time.Time) string {
if match == "%%" {
return "%"
}
format, ok := conv[match]
if ok {
return t.Format(format)
}
switch match {
case "%j":
start := time.Date(t.Year(), time.January, 1, 0, 0, 0, 0, time.UTC)
day := int(t.Sub(start).Hours()/24) + 1
return fmt.Sprintf("%03d", day)
case "%w":
return fmt.Sprintf("%d", t.Weekday())
case "%W", "%U":
start := time.Date(t.Year(), time.January, 1, 23, 0, 0, 0, time.UTC)
week := 0
for start.Before(t) {
week += 1
start = start.Add(WEEK)
}
return fmt.Sprintf("%02d", week)
}
panic(fmt.Errorf("unknown directive - %s", match))
return "" // Make compiler happy
}
// Times returns the start and stop time for
// the closest Day translation to now.
func (d *Day) Times(now time.Time) (closestStart time.Time, closestStop time.Time) {
if now.IsZero() {
Log.Error("Cannot find times without reference")
return
}
if loc, err := d.GetLocation(); loc != nil && err == nil {
now = now.In(loc)
}
// find nearest start time of this slot
if now.Weekday() == d.Day && todayAt(now, d.Start).Before(now) {
// if the schedule is for today
// and we are after that scheduled time,
// then we have found the closest start
closestStart = todayAt(now, d.Start)
} else {
// Step back a day at a time until we find
// the most recent day that matches the day
// of the week of our Day.
for i := 1; i < 8; i++ {
sTime := now.Add(-time.Duration(i) * 24 * time.Hour)
if sTime.Weekday() == d.Day {
closestStart = todayAt(sTime, d.Start)
break
}
}
}
// closestStop is just the closests start plus
// the duration
closestStop = closestStart.Add(d.Duration)
return
}
// given a time, calculate the instant that the log should next roll
func calculateNextRollTime(t time.Time, freq rollFrequency) time.Time {
if freq == RollMinutely {
t = t.Truncate(time.Minute)
t = t.Add(time.Minute)
} else if freq == RollHourly {
t = t.Truncate(time.Hour)
t = t.Add(time.Hour)
} else {
t = t.Truncate(time.Hour)
// easiest way to beat DST bugs is to just iterate
for t.Hour() > 0 {
t = t.Add(-time.Hour)
}
if freq == RollDaily {
t = t.AddDate(0, 0, 1)
} else {
if t.Weekday() == time.Sunday {
t = t.AddDate(0, 0, 7)
} else {
for t.Weekday() != time.Sunday {
t = t.AddDate(0, 0, 1)
}
}
}
}
return t
}
func isGametime(t time.Time) bool {
var start, end time.Time
year := t.Year()
month := t.Month()
day := t.Day()
hour := t.Hour()
loc := t.Location()
switch t.Weekday() {
case time.Monday, time.Tuesday, time.Wednesday, time.Thursday:
start = time.Date(year, month, day, 20, 0, 0, 0, loc)
end = time.Date(year, month, day, 23, 59, 59, 999999999, loc)
case time.Friday:
start = time.Date(year, month, day, 19, 0, 0, 0, loc)
end = time.Date(year, month, day+1, 2, 59, 59, 999999999, loc)
case time.Saturday:
if hour < 3 {
start = time.Date(year, month, day-1, 23, 59, 59, 999999999, loc)
end = time.Date(year, month, day, 2, 59, 59, 999999999, loc)
} else {
start = time.Date(year, month, day, 15, 0, 0, 0, loc)
end = time.Date(year, month, day+1, 2, 59, 59, 999999999, loc)
}
case time.Sunday:
if hour < 3 {
start = time.Date(year, month, day-1, 23, 59, 59, 999999999, loc)
end = time.Date(year, month, day, 2, 59, 59, 999999999, loc)
} else {
start = time.Date(year, month, day, 17, 0, 0, 0, loc)
end = time.Date(year, month, day, 23, 59, 59, 999999999, loc)
}
}
return (t.After(start) && t.Before(end))
}
func getDateString(d time.Time) string {
if d.IsZero() {
return "Date TBC"
}
year, month, day := d.Date()
suffix := "th"
switch day % 10 {
case 1:
if day%100 != 11 {
suffix = "st"
}
case 2:
if day%100 != 12 {
suffix = "nd"
}
case 3:
if day%100 != 13 {
suffix = "rd"
}
}
return d.Weekday().String() + " " + strconv.Itoa(day) + suffix + " " +
month.String() + " " + strconv.Itoa(year)
}
// FmtDateFull returns the full date representation of 't' for 'ti_ER'
func (ti *ti_ER) FmtDateFull(t time.Time) string {
b := make([]byte, 0, 32)
b = append(b, ti.daysWide[t.Weekday()]...)
b = append(b, []byte{0xe1, 0x8d, 0xa1, 0x20}...)
if t.Day() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Day()), 10)
b = append(b, []byte{0x20}...)
b = append(b, ti.monthsWide[t.Month()]...)
b = append(b, []byte{0x20, 0xe1, 0x88, 0x98, 0xe1, 0x8b, 0x93, 0xe1, 0x88, 0x8d, 0xe1, 0x89, 0xb2, 0x20}...)
b = strconv.AppendInt(b, int64(t.Year()), 10)
b = append(b, []byte{0x20}...)
if t.Year() < 0 {
b = append(b, ti.erasWide[0]...)
} else {
b = append(b, ti.erasWide[1]...)
}
return string(b)
}
func (f FileSystem) DateFilepath(date time.Time) string {
filename := fmt.Sprintf("%s_%s_%d_%d.md", date.Weekday(), date.Month().String(), date.Day(), date.Year())
path := path.Join(f.MonthDirectory(date), strings.ToLower(filename))
f.bootstrap(path)
return path
}
// IsWeekdayN reports whether the given date is the nth occurrence of the
// day in the month.
//
// The value of n affects the direction of counting:
// n > 0: counting begins at the first day of the month.
// n == 0: the result is always false.
// n < 0: counting begins at the end of the month.
func IsWeekdayN(date time.Time, day time.Weekday, n int) bool {
cday := date.Weekday()
if cday != day || n == 0 {
return false
}
if n > 0 {
return (date.Day()-1)/7 == (n - 1)
} else {
n = -n
last := time.Date(date.Year(), date.Month()+1,
1, 12, 0, 0, 0, date.Location())
lastCount := 0
for {
last = last.AddDate(0, 0, -1)
if last.Weekday() == day {
lastCount++
}
if lastCount == n || last.Month() != date.Month() {
break
}
}
return lastCount == n && last.Month() == date.Month() &&
last.Day() == date.Day()
}
}
// IsWorkday reports whether a given date is a work day (business day).
func (c *Calendar) IsWorkday(date time.Time) bool {
if IsWeekend(date) || c.IsHoliday(date) {
return false
}
if c.Observed == ObservedExact {
return true
}
day := date.Weekday()
if c.Observed == ObservedMonday && day == time.Monday {
sun := date.AddDate(0, 0, -1)
sat := date.AddDate(0, 0, -2)
return !c.IsHoliday(sat) && !c.IsHoliday(sun)
} else if c.Observed == ObservedNearest {
if day == time.Friday {
sat := date.AddDate(0, 0, 1)
return !c.IsHoliday(sat)
} else if day == time.Monday {
sun := date.AddDate(0, 0, -1)
return !c.IsHoliday(sun)
}
}
return true
}
func (tc *timeClock) isSchoolDay(t time.Time) bool {
if tc.isHoliday(t) {
return false
}
weekDay := t.Weekday()
return weekDay >= time.Monday && weekDay <= time.Friday
}
/* Returns the date range used by the Weekday-Weekend prediction hybrid method
i.e. uses last 5 weekdays if the departure time is on a weekday,
otherwise uses 7/14/21 days prior to the weekend */
func getWeekdayWeekendDateRange(departureTime time.Time) []time.Time {
weekday := departureTime.Weekday()
switch weekday {
/* Handle case weekday */
case time.Monday, time.Tuesday, time.Wednesday, time.Thursday, time.Friday:
dateRange := make([]time.Time, 0)
for i := 1; i <= 7; i++ {
date := departureTime.AddDate(0, 0, -i)
if date.Weekday() == time.Saturday || date.Weekday() == time.Sunday {
continue
}
dateRange = append(dateRange, date)
}
return dateRange
/* Handle case weekend */
case time.Saturday, time.Sunday:
return []time.Time{
departureTime.AddDate(0, 0, -7),
departureTime.AddDate(0, 0, -14),
departureTime.AddDate(0, 0, -21),
}
}
logger.GetLogger().Panicf("Invalid weekday found: %v", weekday)
return nil
}
func TimeDeltaDowInt(base time.Time, wantDow int, deltaUnits int, wantInclusive bool, wantStartOfDay bool) (time.Time, error) {
deltaUnitsAbs := deltaUnits
if deltaUnitsAbs < 1 {
deltaUnitsAbs *= -1
}
deltaDays := int(0)
if deltaUnits < 0 {
deltaDaysTry, err := DaysAgoDow(int(base.Weekday()), wantDow, wantInclusive)
if err != nil {
return base, err
}
deltaDays = deltaDaysTry
} else if deltaUnits > 0 {
deltaDaysTry, err := DaysToDow(int(base.Weekday()), wantDow, wantInclusive)
if err != nil {
return base, err
}
deltaDays = deltaDaysTry
} else {
return base, errors.New("Delta units cannot be 0")
}
if deltaUnitsAbs > 1 {
additional := deltaUnitsAbs - 1
deltaDays += 7 * additional
}
if deltaUnits < 0 {
deltaDays *= -1
}
t1 := base.AddDate(0, 0, deltaDays)
if !wantStartOfDay {
return t1, nil
}
t2 := time.Date(t1.Year(), t1.Month(), t1.Day(), 0, 0, 0, 0, t1.Location())
return t2, nil
}
func getTimeByRangeType(myTime *time.Time, rangeType dataRangeType) (beginTime time.Time, endTime time.Time) {
h, m, s := myTime.Clock()
y, M, d := myTime.Date()
wd := myTime.Weekday()
l := myTime.Location()
var bh, bm, bs, eh, em, es = h, m, s, h, m, s
var by, bM, bd, ey, eM, ed = y, M, d, y, M, d
switch rangeType {
case PerMinute:
bh, bm, bs = h, m, 0
eh, em, es = h, m, 59
by, bM, bd = y, M, d
ey, eM, ed = y, M, d
case PerHour:
bh, bm, bs = h, 0, 0
eh, em, es = h, 59, 59
by, bM, bd = y, M, d
ey, eM, ed = y, M, d
case PerDay:
bh, bm, bs = 0, 0, 0
eh, em, es = 23, 59, 59
by, bM, bd = y, M, d
ey, eM, ed = y, M, d
case PerWeek:
bh, bm, bs = 0, 0, 0
eh, em, es = 23, 59, 59
by, bM, bd = y, M, d-int(time.Sunday+wd)
ey, eM, ed = y, M, d+int(time.Saturday-wd)
case PerMonth:
bh, bm, bs = 0, 0, 0
eh, em, es = 23, 59, 59
by, bM, bd = y, M, 1
ey, eM, ed = y, M+1, 0
case PerSeason:
bh, bm, bs = 0, 0, 0
eh, em, es = 23, 59, 59
switch {
case M >= time.January && M <= time.March:
by, bM, bd = y, 1, 1
case M >= time.April && M <= time.June:
by, bM, bd = y, 4, 1
case M >= time.July && M <= time.September:
by, bM, bd = y, 7, 1
case M >= time.October && M <= time.December:
by, bM, bd = y, 10, 1
}
ey, eM, ed = y, bM+3, 0
case PerYear:
bh, bm, bs = 0, 0, 0
eh, em, es = 23, 59, 59
by, bM, bd = y, 1, 1
ey, eM, ed = y, 12, 31
}
bt := time.Date(by, bM, bd, bh, bm, bs, 0, l)
et := time.Date(ey, eM, ed, eh, em, es, 999999999, l)
return bt, et
}
func strftime(t time.Time, cfmt string) string {
sc := newFlagScanner('%', "", "", cfmt)
for c, eos := sc.Next(); !eos; c, eos = sc.Next() {
if !sc.ChangeFlag {
if sc.HasFlag {
if v, ok := cDateFlagToGo[c]; ok {
sc.AppendString(t.Format(v))
} else {
switch c {
case 'w':
sc.AppendString(fmt.Sprint(int(t.Weekday())))
default:
sc.AppendChar('%')
sc.AppendChar(c)
}
}
sc.HasFlag = false
} else {
sc.AppendChar(c)
}
}
}
return sc.String()
}
// IsDue check if current moment is match fo expression
func (expr *Expr) IsDue(args ...time.Time) bool {
var t time.Time
if len(args) >= 1 {
t = args[0]
} else {
t = time.Now()
}
if expr.minutes.index[uint8(t.Minute())] == false {
return false
}
if expr.hours.index[uint8(t.Hour())] == false {
return false
}
if expr.doms.index[uint8(t.Day())] == false {
return false
}
if expr.months.index[uint8(t.Month())] == false {
return false
}
if expr.dows.index[uint8(t.Weekday())] == false {
return false
}
return true
}
//时间取整
func TruncDate(cyc string, now time.Time) time.Time { // {{{
//解析周期并取得距下一周期的时间
switch {
case cyc == "ss":
//按秒取整
return time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second(), 0, time.Local)
case cyc == "mi":
//按分钟取整
return time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), 0, 0, time.Local)
case cyc == "h":
//按小时取整
return time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, time.Local)
case cyc == "d":
//按日取整
return time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local)
case cyc == "m":
//按月取整
return time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, time.Local)
case cyc == "w":
//按周取整
return time.Date(now.Year(), now.Month(), now.Day()-int(now.Weekday()), 0, 0, 0, 0, time.Local)
case cyc == "q":
//回头再处理
case cyc == "y":
//按年取整
return time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.Local)
}
return time.Now()
} // }}}
func (f FileSystem) WeekFilepath(date time.Time) string {
start := date.AddDate(0, 0, -1*int(date.Weekday()))
year, month, day := start.Date()
filename := strings.ToLower(fmt.Sprintf("week_%s_%d_%d.md", month.String(), day, year))
path := path.Join(f.MonthDirectory(start), filename)
f.bootstrap(path)
return path
}
// StartOfWeek returns the start of the current week for the time.
func StartOfWeek(t time.Time) time.Time {
// Figure out number of days to back up until Mon:
// Sun is 0 -> 6, Sat is 6 -> 5, etc.
toMon := Weekday(t.Weekday())
y, m, d := t.AddDate(0, 0, -int(toMon)).Date()
// Result is 00:00:00 on that year, month, day.
return time.Date(y, m, d, 0, 0, 0, 0, t.Location())
}
// WeekdayInList tests if the weekday of a time is in a given list.
func WeekdayInList(t time.Time, weekdays []time.Weekday) bool {
for _, weekday := range weekdays {
if t.Weekday() == weekday {
return true
}
}
return false
}
func (job *Job) HappensOn(t *time.Time) bool {
freq := job.Msg.GetFrequency()
return int8(freq.GetWeekday()) == int8(t.Weekday()) ||
freq.GetWeekday() == -1 &&
freq.GetMonth() == int32(t.Month()) &&
freq.GetDay() == int32(t.Day())
}
// Matches returns true if the job time has arrived (Alarm clock rings)
func (cj job) Matches(t time.Time) (ok bool) {
return (cj.Month == any || cj.Month == int8(t.Month())) &&
(cj.Day == any || cj.Day == int8(t.Day())) &&
(cj.Weekday == any || cj.Weekday == int8(t.Weekday())) &&
(cj.Hour == any || cj.Hour == int8(t.Hour())) &&
(cj.Minute == any || cj.Minute == int8(t.Minute())) &&
(cj.Second == any || cj.Second == int8(t.Second()))
}
func getWeekdayNum(d time.Time) int {
r := int(d.Weekday())
if r == 0 {
r = 7
}
return r
}
func (q *TQuery) Match(t time.Time) bool {
idxs := []int{t.Minute(), t.Hour(), t.Day(), int(t.Month()), int(t.Weekday())}
for i, idx := range idxs {
if !q.fields[i].Test(uint(idx)) {
return false
}
}
return true
}
func (l *dateLexer) resolveDay(rel time.Time) time.Time {
y, m, _ := rel.Date()
h, n, s := rel.Clock()
rel = time.Date(y, m, l.day, h, n, s, 0, rel.Location())
if DEBUG {
fmt.Printf("Parsed day as %s %s\n", rel.Weekday(), rel)
}
return rel
}