gin_server_admin/commonus/timeSub.go

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
}