You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
535 lines
16 KiB
535 lines
16 KiB
package commonus
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
// 时间相关处理类
|
|
var (
|
|
timeLayoutMap = map[string]string{
|
|
"y": "2006",
|
|
"m": "2006-01",
|
|
"d": "2006-01-02",
|
|
"h": "2006-01-02 15",
|
|
"i": "2006-01-02 15:04",
|
|
"s": "2006-01-02 15:04:05",
|
|
}
|
|
|
|
weekDay = map[string]int{
|
|
"Monday": 1,
|
|
"Tuesday": 2,
|
|
"Wednesday": 3,
|
|
"Thursday": 4,
|
|
"Friday": 5,
|
|
"Saturday": 6,
|
|
"Sunday": 7,
|
|
}
|
|
)
|
|
|
|
/*
|
|
*
|
|
获取本周周一的日期
|
|
*/
|
|
func GetDateOfWeek() (weekMonday string) {
|
|
now := time.Now()
|
|
|
|
offset := int(time.Monday - now.Weekday())
|
|
if offset > 0 {
|
|
offset = -6
|
|
}
|
|
|
|
weekStartDate := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, offset)
|
|
weekMonday = weekStartDate.Format("2006-01-02")
|
|
return
|
|
}
|
|
|
|
/*
|
|
*
|
|
获取本周周日的日期
|
|
*/
|
|
func GetLastWeekDate() (weekMonday string) {
|
|
thisWeekMonday := GetDateOfWeek()
|
|
TimeMonday, _ := time.Parse("2006-01-02", thisWeekMonday)
|
|
lastWeekMonday := TimeMonday.AddDate(0, 0, +6)
|
|
weekMonday = lastWeekMonday.Format("2006-01-02")
|
|
return
|
|
}
|
|
|
|
/*
|
|
*
|
|
获取上周的周一日期
|
|
*/
|
|
func GetFirstWeekDate() (weekMonday string) {
|
|
thisWeekMonday := GetDateOfWeek()
|
|
TimeMonday, _ := time.Parse("2006-01-02", thisWeekMonday)
|
|
lastWeekMonday := TimeMonday.AddDate(0, 0, -7)
|
|
weekMonday = lastWeekMonday.Format("2006-01-02")
|
|
return
|
|
}
|
|
|
|
/*
|
|
*
|
|
获取上周的周日日期
|
|
*/
|
|
func GetFirstWeekLastDate() (weekMonday string) {
|
|
thisWeekMonday := GetFirstWeekDate()
|
|
TimeMonday, _ := time.Parse("2006-01-02", thisWeekMonday)
|
|
lastWeekMonday := TimeMonday.AddDate(0, 0, +6)
|
|
weekMonday = lastWeekMonday.Format("2006-01-02")
|
|
return
|
|
}
|
|
|
|
/*
|
|
*
|
|
获取指定日期的上周的周一日期
|
|
*/
|
|
func GetFirstWeekDateSet(thisWeekMonday string) (weekMonday string) {
|
|
TimeMonday, _ := time.Parse("2006-01-02", thisWeekMonday)
|
|
lastWeekMonday := TimeMonday.AddDate(0, 0, -7)
|
|
weekMonday = lastWeekMonday.Format("2006-01-02")
|
|
return
|
|
}
|
|
|
|
/*
|
|
获取今天时间
|
|
*/
|
|
func GetToDay() (yesterday string) {
|
|
now := time.Now()
|
|
yesTime := now.AddDate(0, 0, 0).Format("2006-01-02") // 获取昨天的时间
|
|
return yesTime
|
|
}
|
|
func GetToDayAll() (yesterday string) {
|
|
now := time.Now()
|
|
yesTime := now.AddDate(0, 0, 0).Format("2006-01-02 15:04:05") // 获取昨天的时间
|
|
return yesTime
|
|
}
|
|
|
|
/*
|
|
获取昨天时间
|
|
*/
|
|
func GetYesterDay() (yesterday string) {
|
|
now := time.Now()
|
|
yesTime := now.AddDate(0, 0, -1).Format("2006-01-02") // 获取昨天的时间
|
|
return yesTime
|
|
}
|
|
|
|
/*
|
|
日期转时间戳
|
|
*/
|
|
func DateToTimeStamp(dataStr string) (timeStamp int64) {
|
|
tmp := "2006-01-02 15:04:05"
|
|
res, _ := time.ParseInLocation(tmp, dataStr, time.Local)
|
|
timeStamp = res.Unix()
|
|
return
|
|
}
|
|
|
|
func DateToTimeStampEs(dataStr string) (timeStamp int64, isTrue bool) {
|
|
isTrue = false
|
|
tmp := "2006-01-02 15:04:05"
|
|
res, err := time.ParseInLocation(tmp, dataStr, time.Local)
|
|
timeStamp = res.Unix()
|
|
if err == nil {
|
|
isTrue = true
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
时间戳转日期
|
|
*/
|
|
func TimeStampToDate(timeStamp int64, timeType int) (dateStr string) {
|
|
timeTemplate := "2006-01-02 15:04:05" //常规类型
|
|
switch timeType {
|
|
case 1:
|
|
timeTemplate = "2006/01/02 15:04:05"
|
|
case 2:
|
|
timeTemplate = "2006/01/02 15:04"
|
|
case 3:
|
|
timeTemplate = "2006/01/02 15"
|
|
case 4:
|
|
timeTemplate = "2006/01/02"
|
|
case 5:
|
|
timeTemplate = "15:04:05"
|
|
case 6:
|
|
timeTemplate = "2006-01-02"
|
|
case 7:
|
|
timeTemplate = "2006-01-02 15"
|
|
case 8:
|
|
timeTemplate = "2006-01-02 15:04"
|
|
case 9:
|
|
timeTemplate = "02"
|
|
case 10:
|
|
timeTemplate = "2006-01"
|
|
case 11:
|
|
timeTemplate = "2006" //年
|
|
case 12:
|
|
timeTemplate = "01" //月
|
|
case 13: //季度
|
|
dayMonth := time.Unix(timeStamp, 0).Format("01")
|
|
datMonthFloat, datMonthFloatErr := strconv.ParseFloat(dayMonth, 10)
|
|
if datMonthFloatErr == nil {
|
|
dateStr = strconv.FormatFloat(math.Ceil(datMonthFloat/3), 'f', -1, 64)
|
|
|
|
} else {
|
|
dateStr = "1"
|
|
}
|
|
// fmt.Printf("dayMonth ---------->%v-----dateStr-->%v---datMonthFloat--->%v---datMonthFloatErr-->%v\n", dayMonth, dateStr, datMonthFloat, datMonthFloatErr)
|
|
return
|
|
case 14:
|
|
timeTemplate = "20060102"
|
|
case 15:
|
|
timeTemplate = "01-02"
|
|
default:
|
|
timeTemplate = "2006-01-02 15:04:05" //常规类型
|
|
}
|
|
dateStr = time.Unix(timeStamp, 0).Format(timeTemplate)
|
|
return
|
|
}
|
|
|
|
// 时间计算(年、季、月、周、日、时、分、秒)
|
|
func ComputingTime(timeStamp int64, timeType int) (timeDataInt int64) {
|
|
var timeData string = "1"
|
|
switch timeType {
|
|
case 1:
|
|
timeData = time.Unix(timeStamp, 0).Format("2006") //年
|
|
case 2:
|
|
dayMonth := time.Unix(timeStamp, 0).Format("01") //季度
|
|
datMonthFloat, datMonthFloatErr := strconv.ParseFloat(dayMonth, 10)
|
|
if datMonthFloatErr == nil {
|
|
timeData = strconv.FormatFloat(math.Ceil(datMonthFloat/3), 'f', -1, 64)
|
|
} else {
|
|
timeData = "1"
|
|
}
|
|
case 3:
|
|
timeData = time.Unix(timeStamp, 0).Format("01") //月份
|
|
case 4: //当前日期为本月第几周
|
|
monthFirstDayStr := DateToTimeStamp(TimeStampToDate(timeStamp, 10) + "-01 00:00:00") //获取指定月第一天时间戳
|
|
dayTime := time.Unix(monthFirstDayStr, 0)
|
|
dayOfWeek := int(dayTime.Weekday()) //获取本月第一天是周几
|
|
if dayOfWeek == 0 {
|
|
dayOfWeek = 7
|
|
}
|
|
|
|
dayNumber, dayNumberErr := strconv.ParseInt(TimeStampToDate(timeStamp, 9), 10, 64) //获取今天是几号
|
|
if dayNumberErr != nil {
|
|
dayNumber = 1
|
|
}
|
|
daysAndWeeksDiff := dayNumber - (8 - int64(dayOfWeek))
|
|
if daysAndWeeksDiff <= 0 {
|
|
timeData = "1"
|
|
} else {
|
|
daysAndWeeksDiffFlot, daysAndWeeksDiffFloatErr := strconv.ParseFloat(strconv.FormatInt(daysAndWeeksDiff, 10), 10)
|
|
if daysAndWeeksDiffFloatErr == nil {
|
|
daysWeeksDiffVal := math.Ceil(daysAndWeeksDiffFlot/7) + 1
|
|
timeData = strconv.FormatFloat(daysWeeksDiffVal, 'f', -1, 64)
|
|
} else {
|
|
timeData = "1"
|
|
}
|
|
}
|
|
case 5:
|
|
timeData = time.Unix(timeStamp, 0).Format("02") //天
|
|
case 7:
|
|
timeData = time.Unix(timeStamp, 0).Format("15") //时
|
|
case 8:
|
|
timeData = time.Unix(timeStamp, 0).Format("04") //分
|
|
case 9:
|
|
timeData = time.Unix(timeStamp, 0).Format("05") //秒
|
|
default:
|
|
timeData = "0"
|
|
}
|
|
timeDataInt, timeDataIntErr := strconv.ParseInt(timeData, 10, 64)
|
|
if timeDataIntErr != nil {
|
|
timeDataInt = 0
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
指定日期起止时间戳
|
|
@startTime
|
|
@endTime
|
|
*/
|
|
func GetStartAndEndTimeStamp(startTime, endTime string) (startTimeStamp, endTimeStamp int64) {
|
|
startTimeStr := startTime + " 00:00:00"
|
|
endTimeStr := endTime + " 23:59:59"
|
|
startTimeStamp = DateToTimeStamp(startTimeStr)
|
|
endTimeStamp = DateToTimeStamp(endTimeStr)
|
|
return
|
|
}
|
|
|
|
// 获取两个时间相差的天数，0表同一天，正数表t1>t2，负数表t1<t2
|
|
func GetDiffDays(t1, t2 time.Time) int64 {
|
|
t1 = time.Date(t1.Year(), t1.Month(), t1.Day(), 0, 0, 0, 0, time.Local)
|
|
t2 = time.Date(t2.Year(), t2.Month(), t2.Day(), 0, 0, 0, 0, time.Local)
|
|
|
|
return int64(t1.Sub(t2).Hours() / 24)
|
|
|
|
}
|
|
|
|
// 获取t1和t2的相差天数，单位：秒，0表同一天，正数表t1>t2，负数表t1<t2
|
|
func GetDiffDaysBySecond(t1, t2 int64) int64 {
|
|
time1 := time.Unix(t1, 0)
|
|
time2 := time.Unix(t2, 0)
|
|
|
|
// 调用上面的函数
|
|
return GetDiffDays(time1, time2)
|
|
}
|
|
|
|
// 获取时间段内每天的开始结束时间
|
|
func StartAndEndTimeOREveryDay(startTime, endTime int64) []map[string]interface{} {
|
|
tianshu := GetDiffDaysBySecond(endTime, startTime)
|
|
var i int64
|
|
timeMapAry := []map[string]interface{}{}
|
|
for i = 0; i <= tianshu; i++ {
|
|
timeStampVal := startTime + (86400 * i)
|
|
dateVal := TimeStampToDate(timeStampVal, 6)
|
|
beginTimg, endDateTime := GetStartAndEndTimeStamp(dateVal, dateVal)
|
|
var timeMap = make(map[string]interface{})
|
|
timeMap["starttime"] = beginTimg
|
|
timeMap["endtime"] = endDateTime
|
|
timeMapAry = append(timeMapAry, timeMap)
|
|
}
|
|
return timeMapAry
|
|
}
|
|
|
|
// 日期字符串转换成time格式
|
|
func StringToTimeIng(unit, str string) (res time.Time) {
|
|
loc, _ := time.LoadLocation("Local")
|
|
// str := t.ToString()
|
|
layout, ok := timeLayoutMap[unit]
|
|
if !ok {
|
|
layout = timeLayoutMap["s"]
|
|
}
|
|
res, _ = time.ParseInLocation(layout, str, loc)
|
|
return
|
|
}
|
|
|
|
// 获取传入的时间所在月份的第一天，即某月第一天的0点。如传入time.Now(), 返回当前月份的第一天0点时间。
|
|
func GetFirstDateOfMonth(d time.Time) time.Time {
|
|
d = d.AddDate(0, 0, -d.Day()+1)
|
|
return GetZeroTime(d)
|
|
}
|
|
|
|
// 获取传入的时间所在月份的第一天，即某月第一天的0点。如传入time.Now(), 返回当前月份的第一天0点时间戳。
|
|
func GetFirstDateOfMonthStamp(d time.Time) (monthStartTimeShamp int64) {
|
|
monthStartTimeShamp = GetFirstDateOfMonth(d).Unix()
|
|
return
|
|
}
|
|
|
|
// 获取传入的时间所在月份的最后一天，即某月最后一天的0点。如传入time.Now(), 返回当前月份的最后一天0点时间。
|
|
func GetLastDateOfMonth(d time.Time) time.Time {
|
|
return GetFirstDateOfMonth(d).AddDate(0, 1, -1)
|
|
}
|
|
|
|
// 获取传入的时间所在月份的最后一天，即某月最后一天的23点59分59秒。如传入time.Now(), 返回当前月份的最后一天23点59分59秒的时间戳。
|
|
func GetLastDateMonthAll(d time.Time) (monthEndTimeShamp int64) {
|
|
monthEndTimeShamp = GetLastDateOfMonth(d).Unix() + 86399
|
|
return
|
|
}
|
|
|
|
// 获取某一天的0点时间
|
|
func GetZeroTime(d time.Time) time.Time {
|
|
return time.Date(d.Year(), d.Month(), d.Day(), 0, 0, 0, 0, d.Location())
|
|
}
|
|
|
|
// 指定日期月起止时间戳
|
|
func GetMonthStartOrEndTime(d time.Time) (monthStartTimgStamp, monthEndTimeStamp int64) {
|
|
monthStartTimgStamp = GetFirstDateOfMonthStamp(d)
|
|
monthEndTimeStamp = GetLastDateMonthAll(d)
|
|
return
|
|
}
|
|
|
|
//获取一周开始结束时间
|
|
/*
|
|
@t 时间
|
|
callback
|
|
@strarTime 指定周开始时间
|
|
@endTime 指定周结束时间
|
|
@weekInt 本月第几周
|
|
*/
|
|
func WeekStartAdnEndTime(t time.Time) (strarTime, endTime int64, weekInt int) {
|
|
endStr := t.Weekday().String() //周几
|
|
firstInt := (weekDay[endStr] - 1) //前边有几天
|
|
lastInt := 7 - weekDay[endStr] //后边有几天
|
|
plus := int64(86400 * lastInt) //计算结束时间加量
|
|
owe := int64(86400 * firstInt) //计算开始时间加量
|
|
endDay := time.Unix(t.Unix()+plus+86399, 0) //结束时间
|
|
startDay := time.Unix(t.Unix()-owe, 0) //开始时间
|
|
//开始与结束时间转换时间戳
|
|
strarTime = startDay.Unix()
|
|
endTime = endDay.Unix()
|
|
monthStartTimgStamp, monthEndTimeStamp := GetMonthStartOrEndTime(t) //计算本月开始与结束时间（时间戳）
|
|
//判断指定日期所在月周的开始与结束日期
|
|
if monthStartTimgStamp-strarTime > 0 {
|
|
strarTime = monthStartTimgStamp
|
|
}
|
|
if monthEndTimeStamp-endTime < 0 {
|
|
endTime = monthEndTimeStamp
|
|
}
|
|
|
|
monthFirstDay := time.Unix(monthStartTimgStamp, 0).Weekday().String() //指定日期所在月第一天是周几
|
|
|
|
todayInt := t.Local().Day() //今天几号
|
|
currentWeek := weekDay[monthFirstDay] //指定日期所在月第一天是周几（转换成int定量）
|
|
daySet := todayInt - (8 - currentWeek) //日期差量
|
|
if daySet <= 0 {
|
|
weekInt = 1
|
|
} else {
|
|
weekInt = int(math.Ceil(float64(daySet)/7.0)) + 1 //计算周
|
|
}
|
|
return
|
|
}
|
|
|
|
// 计算指定日期周一
|
|
func SetDateWeekFirstTime(t time.Time) (weekInt string) {
|
|
offset := int(time.Monday - t.Weekday())
|
|
if offset > 0 {
|
|
offset = -6
|
|
}
|
|
weekStartDate := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, offset)
|
|
weekInt = weekStartDate.Format("2006-01-02")
|
|
return
|
|
}
|
|
|
|
/*
|
|
获取上周起止时间
|
|
*/
|
|
func FirstWeekStartAdnEndTime(t time.Time) (strarTime, endTime int64, weekInt int) {
|
|
//计算周一
|
|
firstWeekDay := SetDateWeekFirstTime(t) //指定日期所在周的周一日期
|
|
firstWeekDayStringToTime := StringToTimeIng("d", firstWeekDay)
|
|
monthFirst := int64(firstWeekDayStringToTime.Month()) //获取周一所在月
|
|
monthSet := int64(t.Month()) //当前日期所在月
|
|
// fmt.Printf("%v=>%v=>%v\n", firstWeekDay, int(t.Month()), t)
|
|
|
|
strarTime = monthFirst
|
|
endTime = monthSet
|
|
weekInt = 250
|
|
//判断是否在同一个月
|
|
if monthFirst == monthSet {
|
|
firstWeekDay = firstWeekDay + " 00:00:00"
|
|
weekFirstDayTime := DateToTimeStamp(firstWeekDay) - 43200
|
|
weekFirstDayTimeToStr := TimeStampToDate(weekFirstDayTime, 6)
|
|
weekDayStrToTime := StringToTimeIng("d", weekFirstDayTimeToStr)
|
|
strarTime, endTime, weekInt = WeekStartAdnEndTime(weekDayStrToTime)
|
|
} else {
|
|
strarTime, endTime, weekInt = WeekStartAdnEndTime(firstWeekDayStringToTime)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 获取指定时间当月第一周起止时间
|
|
func GetSetUpDayTimeToMonthStartAndEndTime(monthStartTime int64) (strarTime, endTime int64) {
|
|
t := time.Unix(monthStartTime, 0)
|
|
fmt.Println(time.Unix(monthStartTime, 0))
|
|
|
|
endStr := t.Weekday().String()
|
|
firstInt := (weekDay[endStr] - 1)
|
|
lastInt := 7 - weekDay[endStr]
|
|
plus := int64(86400 * lastInt) //计算结束时间加量
|
|
owe := int64(86400 * firstInt) //计算开始时间加量
|
|
endDay := time.Unix(t.Unix()+plus+86399, 0) //结束时间
|
|
startDay := time.Unix(t.Unix()-owe, 0) //开始时间
|
|
strarTime = startDay.Unix()
|
|
endTime = endDay.Unix()
|
|
monthStartTimgStamp, monthEndTimeStamp := GetMonthStartOrEndTime(t)
|
|
if monthStartTimgStamp-strarTime > 0 {
|
|
strarTime = monthStartTimgStamp
|
|
}
|
|
if monthEndTimeStamp-endTime < 0 {
|
|
endTime = monthEndTimeStamp
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
获取季度的起止时间
|
|
*/
|
|
func GetQuarterDay(t time.Time) (string, int, int64, int64) {
|
|
year := t.Format("2006")
|
|
month := int(t.Month())
|
|
var firstOfQuarter string
|
|
var lastOfQuarter string
|
|
var currentQuarter int
|
|
|
|
if month >= 1 && month <= 3 {
|
|
//1月1号
|
|
firstOfQuarter = year + "-01-01 00:00:00"
|
|
lastOfQuarter = year + "-03-31 23:59:59"
|
|
currentQuarter = 1
|
|
} else if month >= 4 && month <= 6 {
|
|
firstOfQuarter = year + "-04-01 00:00:00"
|
|
lastOfQuarter = year + "-06-30 23:59:59"
|
|
currentQuarter = 2
|
|
} else if month >= 7 && month <= 9 {
|
|
firstOfQuarter = year + "-07-01 00:00:00"
|
|
lastOfQuarter = year + "-09-30 23:59:59"
|
|
currentQuarter = 3
|
|
} else {
|
|
firstOfQuarter = year + "-10-01 00:00:00"
|
|
lastOfQuarter = year + "-12-31 23:59:59"
|
|
currentQuarter = 4
|
|
}
|
|
quarterStartTime := DateToTimeStamp(firstOfQuarter)
|
|
quarterEndTime := DateToTimeStamp(lastOfQuarter)
|
|
return year, currentQuarter, quarterStartTime, quarterEndTime
|
|
}
|
|
|
|
// 获取指定时间的前N个月的起止时间
|
|
func AppointTimeFrontMonth(timeVal time.Time, diff int) (startTime, endTime int64) {
|
|
diff = diff * -1
|
|
lastMonthFirstDay := timeVal.AddDate(0, diff, -timeVal.Day()+1)
|
|
startTime = time.Date(lastMonthFirstDay.Year(), lastMonthFirstDay.Month(), lastMonthFirstDay.Day(), 0, 0, 0, 0, timeVal.Location()).Unix()
|
|
lastMonthEndDay := lastMonthFirstDay.AddDate(0, 1, -1)
|
|
endTime = time.Date(lastMonthEndDay.Year(), lastMonthEndDay.Month(), lastMonthEndDay.Day(), 23, 59, 59, 0, timeVal.Location()).Unix()
|
|
return
|
|
}
|
|
|
|
// 获取上月月份，起止时间
|
|
func GetLastMonth() (yearMonth, startMonth, endMonth string) {
|
|
dataTypeAll := "2006-01-02"
|
|
dataType := "2006-01"
|
|
year, month, _ := time.Now().Date()
|
|
thisMonth := time.Date(year, month, 1, 0, 0, 0, 0, time.Local)
|
|
startMonth = thisMonth.AddDate(0, -1, 0).Format(dataTypeAll)
|
|
endMonth = thisMonth.AddDate(0, 0, -1).Format(dataTypeAll)
|
|
yearMonth = thisMonth.AddDate(0, -1, 0).Format(dataType)
|
|
// fmt.Printf("year------>%v------year------->%v---thisMonth---->%v---start---->%v---end---->%v---yearMonth---->%v\n", year, month, thisMonth, startMonth, endMonth, yearMonth)
|
|
return
|
|
}
|
|
|
|
// 获取指定月的起止时间
|
|
func GetAppointMonthStarAndEndTime(dayTime string) (startTime, endTime int64) {
|
|
dataTypeAll := "2006-01-02"
|
|
dayTime = fmt.Sprintf("%v-%v", dayTime, "01")
|
|
firstToTime := StringToTimeIng("d", dayTime)
|
|
startTimeStr := fmt.Sprintf("%v 00:00:00", firstToTime.AddDate(0, 0, 0).Format(dataTypeAll))
|
|
endTimeStr := fmt.Sprintf("%v 23:59:59", firstToTime.AddDate(0, 1, -1).Format(dataTypeAll))
|
|
// startTime = dayTime
|
|
startTime, _ = DateToTimeStampEs(startTimeStr)
|
|
endTime, _ = DateToTimeStampEs(endTimeStr)
|
|
return
|
|
}
|
|
|
|
// 获取指定月的起止时间
|
|
func GetAppointMonthStarAndEndTimeInt(monthStartTime int64) (monthStartTimgStamp, monthEndTimeStamp int64) {
|
|
t := time.Unix(monthStartTime, 0)
|
|
monthStartTimgStamp, monthEndTimeStamp = GetMonthStartOrEndTime(t)
|
|
return
|
|
}
|
|
|
|
// 获取指定月的起止时间副本
|
|
func GetAppointMonthStarAndEndTimeEs(dayTime string) (startTime, endTime int64) {
|
|
dataTypeAll := "2006-01-02"
|
|
firstToTime := StringToTimeIng("d", dayTime)
|
|
startTimeStr := fmt.Sprintf("%v 00:00:00", firstToTime.AddDate(0, 0, 0).Format(dataTypeAll))
|
|
endTimeStr := fmt.Sprintf("%v 23:59:59", firstToTime.AddDate(0, 1, -1).Format(dataTypeAll))
|
|
// startTime = dayTime
|
|
startTime, _ = DateToTimeStampEs(startTimeStr)
|
|
endTime, _ = DateToTimeStampEs(endTimeStr)
|
|
return
|
|
}
|
|
|