eta_crawler/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月G",
		"03": "3月H",
		"04": "4月J",
		"05": "5月K",
		"06": "6月M",
		"07": "7月N",
		"08": "8月X",
		"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
}

// 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
}

// 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
}

// GetCurrentYear 获取当前年份 转换时间格式 dateText 格式为 2024-08-03 --> 2024年
func GetCurrentYear(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年", shortYear), 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
}

// 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
}

// 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
}