eta_data_analysis/utils/date_util.go

// Package utils @Author gmy 2024/8/6 16:06:00
package utils

import (
	"fmt"
	"strconv"
	"strings"
	"time"
)

// ParseDateAndWeek parseDateAndWeek 解析日期并计算当前周数 ==> 24年31周
func ParseDateAndWeek(dateText string) (string, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(strings.Split(dateText, " ")[0]))
	if err != nil {
		return "", fmt.Errorf("failed to parse report date: %v", err)
	}

	// 计算年份和周数
	year, week := reportDate.ISOWeek()
	// 获取年份的后两位
	shortYear := year % 100
	targetWeek := fmt.Sprintf("%02d年第%d周", shortYear, week)

	return targetWeek, nil
}

// ParseDateAndMonth 解析时间并计算当前月份 和 后两月 1月就是1月F，二月是二月G 规则：F=1月，G=2月，H=3月，J=4月，K=5月，M=6月，N=7月，Q=8月，U=9月，V=10月，X=11月，Z=12月
func ParseDateAndMonth(dateText string) ([]string, error) {
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(strings.Split(dateText, " ")[0]))
	if err != nil {
		return nil, fmt.Errorf("failed to parse report date: %v", err)
	}

	months := make([]string, 3)
	monthMap := map[string]string{
		"01": "1月F",
		"02": "2月G",
		"03": "3月H",
		"04": "4月J",
		"05": "5月K",
		"06": "6月M",
		"07": "7月N",
		"08": "8月Q",
		"09": "9月X",
		"10": "10月X",
		"11": "11月X",
		"12": "12月Z",
	}

	for i := 0; i < 3; i++ {
		month := reportDate.AddDate(0, i, 0).Format("01")
		months[i] = monthMap[month]
	}

	return months, nil
}

// ParseDateAndMonthColzaOil 油菜籽 进口成本 时间映射
func ParseDateAndMonthColzaOil(dateText string) ([]string, error) {
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(strings.Split(dateText, " ")[0]))
	if err != nil {
		return nil, fmt.Errorf("failed to parse report date: %v", err)
	}

	months := make([]string, 3)
	monthMap := map[string]string{
		"01": "1月F",
		"02": "2月H",
		"03": "3月H",
		"04": "4月K",
		"05": "5月K",
		"06": "6月N",
		"07": "7月N",
		"08": "8月X",
		"09": "9月X",
		"10": "10月X",
		"11": "11月X",
		"12": "12月F",
	}

	for i := 0; i < 3; i++ {
		month := reportDate.AddDate(0, i, 0).Format("01")
		months[i] = monthMap[month]
	}

	return months, nil
}

// GetCurrentTime 获取当前时间 格式为 2024-08-07 15:29:58
func GetCurrentTime() string {
	return time.Now().Format("2006-01-02 15:04:05")
}

// ConvertTimeFormat 转换时间格式 dateText 格式为 2024-08-03 07:53 --> 2024-08-03
func ConvertTimeFormat(dateText string) (string, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02 15:04", strings.TrimSpace(dateText))
	if err != nil {
		return "", fmt.Errorf("failed to parse report date: %v", err)
	}

	return reportDate.Format("2006-01-02"), nil
}

// GetNextThreeMonthsNoYear 获取当前月和后两月 不带年份，转换时间格式 dateText 格式为 2024-08-03 --> 8月,9月,10月
func GetNextThreeMonthsNoYear(dateText string) ([]string, error) {
	// 解析日期字符串为时间类型
	date, err := time.Parse("2006-01-02", dateText)
	if err != nil {
		return nil, fmt.Errorf("日期解析错误: %v", err)
	}

	// 存储结果的切片
	var result []string

	// 获取本月及后两个月的月份
	for i := 0; i < 3; i++ {
		month := int(date.Month())

		// 构建并添加当前年月到结果中
		result = append(result, fmt.Sprintf("%d月", month))

		// 将日期加一个月
		date = date.AddDate(0, 1, 0)
	}

	return result, nil
}

// GetNextThreeMonthsLastDay 取当前月的最后一天和后两个月的最后一天 时间格式为 2024-08-03 --> 2024-08-31, 2024-09-30, 2024-10-31
func GetNextThreeMonthsLastDay(dateText string) ([]string, error) {
	// 解析日期字符串为时间类型
	date, err := time.Parse("2006-01-02", dateText)
	if err != nil {
		return nil, fmt.Errorf("日期解析错误: %v", err)
	}

	// 存储结果的切片
	var result []string

	// 获取本月及后两个月的最后一天
	for i := 0; i < 3; i++ {
		// 获取下个月的第一天
		nextMonth := date.AddDate(0, 1, 0)

		// 获取当前月的最后一天
		lastDay := nextMonth.AddDate(0, 0, -nextMonth.Day())

		// 添加到结果中
		result = append(result, lastDay.Format("2006-01-02"))

		// 将日期加一个月
		date = date.AddDate(0, 1, 0)
	}

	return result, nil
}

// GetElementInSlice 获取切片中特定的元素，判断传入月份是否在当前切片月份匹配，如果匹配则返回切片中对应的元素 参数格式为 dateTexts month, [2024-08-31, 2024-09-30, 2024-10-31] 08 --> 2024-08-31, 07 --> nil
func GetElementInSlice(dateTexts []string, month string) (string, error) {
	for _, dateText := range dateTexts {
		reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
		if err != nil {
			return "", fmt.Errorf("failed to parse report date: %v", err)
		}

		if strings.HasSuffix(reportDate.Format("2006-01"), month) {
			return dateText, nil
		}
	}

	return "", fmt.Errorf("未找到匹配的月份")
}

// StringToTime string 类型时间转换为 time 类型时间 dateText 格式为 2024-08-03 00:00:00 --> 2024-08-03 00:00:00
func StringToTime(dateText string) (time.Time, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02 15:04:05", strings.TrimSpace(dateText))
	if err != nil {
		return time.Time{}, fmt.Errorf("failed to parse report date: %v", err)
	}

	return reportDate, nil
}

// StringToTimeZero string 类型时间转换为 time dateText 格式为 2024-08-03 --> 2024-08-03 00:00:00
func StringToTimeZero(dateText string) (time.Time, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
	if err != nil {
		return time.Time{}, fmt.Errorf("failed to parse report date: %v", err)
	}

	return reportDate, nil
}

// GetWeekdaysInSameWeek 拿到传入时间本周当前工作日的时间列表，时间格式 dataText 格式为 2024-08-03 --> 8月3日
func GetWeekdaysInSameWeek(dateStr string) ([]string, error) {
	// 解析输入日期字符串
	t, err := time.Parse("2006-01-02", dateStr)
	if err != nil {
		return nil, err
	}

	// 获取星期几
	weekday := t.Weekday()

	// 计算星期一的日期
	monday := t.AddDate(0, 0, -int(weekday)+1)

	// 生成这周的工作日列表（周一至周五）
	var weekdays []string
	for i := 0; i < 5; i++ {
		day := monday.AddDate(0, 0, i)
		weekdays = append(weekdays, fmt.Sprintf("%d月%d日", day.Month(), day.Day()))
	}

	return weekdays, nil
}

// ConvertToDate 转换后获取当前传入的时间 时间格式为 7月22日 --> 2024-07-22
func ConvertToDate(dateText string) (string, error) {
	// 假设当前年份为 2024
	currentYear := time.Now().Year()

	// 分割日期字符串
	parts := strings.Split(dateText, "月")
	if len(parts) != 2 {
		return "", fmt.Errorf("日期格式错误")
	}

	// 获取月和日的部分
	month, err := strconv.Atoi(parts[0])
	if err != nil {
		return "", fmt.Errorf("月份解析错误: %v", err)
	}
	day, err := strconv.Atoi(strings.TrimSuffix(parts[1], "日"))
	if err != nil {
		return "", fmt.Errorf("日期解析错误: %v", err)
	}

	// 构建日期
	date := time.Date(currentYear, time.Month(month), day, 0, 0, 0, 0, time.Local)

	// 格式化为 "2024-07-22"
	return date.Format("2006-01-02"), nil
}

// ConvertTimeFormatToYearMonthDay 转换时间格式 dateText 格式为 2024-08-03 --> 24年8月3日
func ConvertTimeFormatToYearMonthDay(dateText string) (string, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
	if err != nil {
		return "", fmt.Errorf("failed to parse report date: %v", err)
	}

	// 获取年份的后两位
	shortYear := reportDate.Year() % 100

	return fmt.Sprintf("%02d年%d月%d日", shortYear, reportDate.Month(), reportDate.Day()), nil
}

// GetCurrentYearAndLastYear 获取当前年份和前一年的年份 转换时间格式 dateText 格式为 2024-08-03 --> 2024年,2023年
func GetCurrentYearAndLastYear(dateText string) ([]string, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
	if err != nil {
		return nil, fmt.Errorf("failed to parse report date: %v", err)
	}

	years := make([]string, 2)
	year := reportDate.Year()

	// 当前年份
	years[0] = fmt.Sprintf("%d年", year)
	// 前一年
	years[1] = fmt.Sprintf("%d年", year-1)

	return years, nil
}

// ConvertTimeFormatToYearMonth 转换时间格式 dateText 返回本月 和 后两月 格式为 2024-08-03 --> 2024年8月，2024-10-03 --> 2024年10月
func ConvertTimeFormatToYearMonth(dateText string) ([]string, error) {

	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
	if err != nil {
		return nil, fmt.Errorf("failed to parse report date: %v", err)
	}

	months := make([]string, 3)
	for i := 0; i < 3; i++ {
		month := reportDate.AddDate(0, i, 0).Format("2006年1月")
		months[i] = month
	}

	return months, nil
}

// GetYearMonthNoYear 获取本月和后两月的年月 2024-08-03 --> 24年8月，24年9月，24年10月
func GetYearMonthNoYear(dateText string) ([]string, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
	if err != nil {
		return nil, fmt.Errorf("failed to parse report date: %v", err)
	}

	months := make([]string, 3)
	for i := 0; i < 3; i++ {
		month := reportDate.AddDate(0, i, 0).Format("06年1月")
		months[i] = month
	}

	return months, nil
}

// GetCurrentYearAndNextYear 获取当时所在得年度和明年得年度列表 2024-08-03 --> 2023/24年度, 2024/25年度
func GetCurrentYearAndNextYear(dateText string) ([]string, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
	if err != nil {
		return nil, fmt.Errorf("failed to parse report date: %v", err)
	}

	years := make([]string, 2)
	year := reportDate.Year()

	// 当前年度
	years[0] = fmt.Sprintf("%d/%02d年度", year-1, year%100)
	// 下一年度
	years[1] = fmt.Sprintf("%d/%02d年度", year, (year+1)%100)

	return years, nil
}

// IsSameMonth 判断当前传入年月是否是同一月 2024-08-03, 2024-08 --> true, 2024-08-03, 2024-07 --> false
func IsSameMonth(dateText1, dateText2 string) (bool, error) {
	// 解析日期
	date1, err := time.Parse("2006-01-02", strings.TrimSpace(dateText1))
	if err != nil {
		return false, fmt.Errorf("failed to parse date1: %v", err)
	}

	date2, err := time.Parse("2006-01", strings.TrimSpace(dateText2))
	if err != nil {
		return false, fmt.Errorf("failed to parse date2: %v", err)
	}

	return date1.Year() == date2.Year() && date1.Month() == date2.Month(), nil
}

// GetLastDayOfMonth 获取传入年月的最后一天 dateText 格式为 2024-08 --> 2024-08-31
func GetLastDayOfMonth(dateText string) (string, error) {
	// 解析日期
	date, err := time.Parse("2006-01", strings.TrimSpace(dateText))
	if err != nil {
		return "", fmt.Errorf("failed to parse date: %v", err)
	}

	// 获取下个月的第一天
	nextMonth := date.AddDate(0, 1, 0)

	// 获取本月的最后一天
	lastDay := nextMonth.AddDate(0, 0, -1)

	return lastDay.Format("2006-01-02"), nil
}

// ConvertMonthToNumber 时间转换 格式 8月 --> 08
func ConvertMonthToNumber(dateText string) (string, error) {
	// 去掉字符串中的 "月"
	trimmed := strings.TrimSuffix(strings.TrimSpace(dateText), "月")

	// 将月份转换为整数
	month, err := strconv.Atoi(trimmed)
	if err != nil {
		return "", fmt.Errorf("failed to parse month: %v", err)
	}

	return fmt.Sprintf("%02d", month), nil
}

// 时间转换 格式 1 --> 01
func ConvertMonthToNumber1(dateText string) (string, error) {
	// 将月份转换为整数
	month, err := strconv.Atoi(dateText)
	if err != nil {
		return "", fmt.Errorf("failed to parse month: %v", err)
	}

	return fmt.Sprintf("%02d", month), nil
}

// GetNextThreeMonths 获取传入时间的本月及后两月的年月 2024-08-03 --> 24年8月
func GetNextThreeMonths(dateText string) ([]string, error) {
	// 解析日期字符串为时间类型
	date, err := time.Parse("2006-01-02", dateText)
	if err != nil {
		return nil, fmt.Errorf("日期解析错误: %v", err)
	}

	// 存储结果的切片
	var result []string

	// 获取本月及后两个月的年份和月份
	for i := 0; i < 3; i++ {
		year := date.Year() % 100
		month := int(date.Month())

		// 构建并添加当前年月到结果中
		result = append(result, fmt.Sprintf("%d年%d月", year, month))

		// 将日期加一个月
		date = date.AddDate(0, 1, 0)
	}

	return result, nil
}

// IsCurrentYear 判断是否是当前年度 传入日期格式为 2023/24年度  --> true, 2024/25年度 --> false
func IsCurrentYear(dateText string) (bool, error) {
	// 去掉字符串中的 "年度"
	trimmed := strings.TrimSuffix(strings.TrimSpace(dateText), "年度")

	// 分割年份，例如 "2023/24" -> ["2023", "24"]
	parts := strings.Split(trimmed, "/")
	if len(parts) != 2 {
		return false, fmt.Errorf("invalid date format: %s", dateText)
	}

	// 将前一年的年份转换为整数
	startYear, err := strconv.Atoi(parts[0])
	if err != nil {
		return false, fmt.Errorf("failed to parse start year: %v", err)
	}

	// 获取当前年份
	currentYear := time.Now().Year()

	// 如果当前年份等于 dateText 中的后一年的年份，返回 true
	if currentYear == startYear+1 {
		return true, nil
	}

	return false, nil
}

// GetNextYearLastDay 获取明年本月份的最后一天 2024-08-03 --> 2025-08-31
func GetNextYearLastDay(dateText string) (string, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
	if err != nil {
		return "", fmt.Errorf("failed to parse report date: %v", err)
	}

	// 获取下一年的年份
	nextYear := reportDate.Year() + 1
	// 获取本月份的最后一天
	lastDay := time.Date(nextYear, reportDate.Month()+1, 0, 0, 0, 0, 0, reportDate.Location())

	return lastDay.Format("2006-01-02"), nil
}

// GetYearMonth 获取年月日 2024-08-03 --> 2024-08
func GetYearMonth(dateText string) (string, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
	if err != nil {
		return "", fmt.Errorf("failed to parse report date: %v", err)
	}

	return reportDate.Format("2006-01"), nil
}

// GetCurrentMonth 获取当前月份 2024-08-03 --> 8月
func GetCurrentMonth(dateText string) (string, error) {
	// 解析日期
	reportDate, err := time.Parse("2006-01-02", strings.TrimSpace(dateText))
	if err != nil {
		return "", fmt.Errorf("failed to parse report date: %v", err)
	}

	// 计算月份
	month := reportDate.Month()

	return fmt.Sprintf("%d月", month), nil
}

// GetCurrentYearMonth 获取当前年月 yyyyMM
func GetCurrentYearMonth() string {
	// 获取当前时间
	now := time.Now()

	// 格式化为 "YYYYMM" 形式
	yearMonth := now.Format("200601")

	return yearMonth
}

// ConvertDateFormat 转换时间格式 MM-dd-yy --> yyyy-MM-dd
func ConvertDateFormat(dataText string) (string, error) {
	// 定义输入和输出的时间格式
	inputFormat := "01-02-06"    // MM-dd-yy
	outputFormat := "2006-01-02" // yyyy-MM-dd

	// 解析输入的日期
	date, err := time.Parse(inputFormat, dataText)
	if err != nil {
		return "", err
	}

	// 格式化为输出格式
	return date.Format(outputFormat), nil
}

// ConvertDateFormat2 转换时间格式 yyyy-MMQ --> 取每一季度最后一天，例如 2024-01Q --> 2024-03-31
func ConvertDateFormat2(dataText string) (string, error) {

	// 提取年份和季度信息
	yearStr := dataText[:4]
	quarterStr := dataText[6:7]

	// 转换年份
	year, err := strconv.Atoi(yearStr)
	if err != nil {
		return "", fmt.Errorf("无效的年份: %v", err)
	}

	// 根据季度选择最后一天
	var endOfQuarter string
	switch quarterStr {
	case "1":
		endOfQuarter = fmt.Sprintf("%d-03-31", year)
	case "2":
		endOfQuarter = fmt.Sprintf("%d-06-30", year)
	case "3":
		endOfQuarter = fmt.Sprintf("%d-09-30", year)
	case "4":
		endOfQuarter = fmt.Sprintf("%d-12-31", year)
	default:
		return "", fmt.Errorf("无效的季度: %s", quarterStr)
	}

	// 确保日期格式正确
	_, err = time.Parse("2006-01-02", endOfQuarter)
	if err != nil {
		return "", fmt.Errorf("日期解析失败: %v", err)
	}

	return endOfQuarter, nil
}

// ConvertDateFormat3 转换时间格式 Jan-23 --> 2023-01-31
func ConvertDateFormat3(dataText string) (string, error) {
	// 拆分月份和年份
	parts := strings.Split(dataText, "-")
	if len(parts) != 2 {
		return "", fmt.Errorf("日期格式不正确")
	}

	// 提取月份和年份
	monthStr := parts[0]
	yearStr := parts[1]

	// 转换年份
	year, err := strconv.Atoi(yearStr)
	if err != nil {
		return "", fmt.Errorf("无效的年份: %v", err)
	}

	// 获取月份数字
	month, err := time.Parse("Jan", monthStr)
	if err != nil {
		return "", fmt.Errorf("无效的月份: %v", err)
	}

	// 计算最后一天
	lastDay := time.Date(year+2000, month.Month()+1, 0, 0, 0, 0, 0, time.UTC) // 直接设置为下个月的第一天，再设为0日得到上个月最后一天

	return lastDay.Format("2006-01-02"), nil
}

// ConvertDateFormat4 转换时间格式 2022 --> 2022-12-31
func ConvertDateFormat4(dataText string) (string, error) {
	// 解析输入年份
	year, err := strconv.Atoi(dataText)
	if err != nil {
		return "", fmt.Errorf("无法解析年份: %v", err)
	}

	// 创建该年最后一天的日期
	lastDay := time.Date(year, time.December, 31, 0, 0, 0, 0, time.UTC)

	// 返回格式化后的日期字符串
	return lastDay.Format("2006-01-02"), nil
}

// ConvertDateFormat5 转换时间格式 yyyy-MM-dd HH:mm:ss --> yyyy-MM-dd
func ConvertDateFormat5(dataText string) (string, error) {
	// 解析输入的日期和时间
	dateTime, err := time.Parse("2006-01-02 15:04:05", dataText)
	if err != nil {
		return "", err
	}

	// 格式化为输出格式
	return dateTime.Format("2006-01-02"), nil
}

// ConvertDateFormat6 转换时间格式 2023-March --> 2023-03-31
func ConvertDateFormat6(dataText string) (string, error) {
	// 拆分年份和月份
	parts := strings.Split(dataText, "-")
	if len(parts) != 2 {
		return "", fmt.Errorf("日期格式不正确")
	}

	// 提取年份和月份
	yearStr := parts[0]
	monthStr := parts[1]

	// 转换年份
	year, err := strconv.Atoi(yearStr)
	if err != nil {
		return "", fmt.Errorf("无效的年份: %v", err)
	}

	// 获取月份数字
	month, err := time.Parse("January", monthStr)
	if err != nil {
		return "", fmt.Errorf("无效的月份: %v", err)
	}

	// 获取最后一天
	lastDay := time.Date(year, month.Month()+1, 0, 0, 0, 0, 0, time.UTC) // 使用月份数字加1，再设为0日得到上个月最后一天

	return lastDay.Format("2006-01-02"), nil
}