Project_PlatForm/000_通用版本/098_数据通讯/DataBaseProcessing/util/TimeParser.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace DataBaseProcessing
{
    public class TimeParser
    {
        // 定义时间解析规则表
        public static Dictionary<string, Func<DateTime[]>> timeParsingRules = new Dictionary<string, Func<DateTime[]>>
        {
            { "今天", ParseToday },
            { "昨天", ParseYesterday },
            { "明天", ParseTomorrow },
            { "上个月", ParseLastMonth },
            { "下个月", ParseNextMonth },
            { "今年", ParseThisYear },
            { "去年", ParseLastYear },
            { "明年", ParseNextYear },
            { "上个季度", ParseLastQuarter },
            { "下个季度", ParseNextQuarter },
            { "本季度", ParseThisQuarter },
            { "上周", ParseLastWeek },
            { "下周", ParseNextWeek },
            { "上个财年", ParseLastFiscalYear },
            { "今年至今", ParseYearToDate },
            { "上个季度至今", ParseLastQuarterToDate }
        };

        // 通用解析函数，解析时间短语
        public static string ParseDate(string timePhrase)
        {
            foreach (var rule in timeParsingRules)
            {
                if (timePhrase.Contains(rule.Key))
                {
                    var dateRange = rule.Value.Invoke();
                    return $"起始日期: {dateRange[0]:yyyy-MM-dd}, 结束日期: {dateRange[1]:yyyy-MM-dd}";
                }
            }
            return "无法解析该时间短语";
        }

        // 解析"今天"
        private static DateTime[] ParseToday()
        {
            DateTime today = DateTime.Today;
            return new DateTime[] { today, today };
        }

        // 解析"昨天"
        private static DateTime[] ParseYesterday()
        {
            DateTime yesterday = DateTime.Today.AddDays(-1);
            return new DateTime[] { yesterday, yesterday };
        }

        // 解析"明天"
        private static DateTime[] ParseTomorrow()
        {
            DateTime tomorrow = DateTime.Today.AddDays(1);
            return new DateTime[] { tomorrow, tomorrow };
        }

        // 解析"上个月"
        private static DateTime[] ParseLastMonth()
        {
            DateTime now = DateTime.Now;
            DateTime startDate = new DateTime(now.Year, now.Month, 1).AddMonths(-1);
            DateTime endDate = startDate.AddMonths(1).AddDays(-1);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"下个月"
        private static DateTime[] ParseNextMonth()
        {
            DateTime now = DateTime.Now;
            DateTime startDate = new DateTime(now.Year, now.Month, 1).AddMonths(1);
            DateTime endDate = startDate.AddMonths(1).AddDays(-1);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"今年"
        private static DateTime[] ParseThisYear()
        {
            DateTime now = DateTime.Now;
            DateTime startDate = new DateTime(now.Year, 1, 1);
            DateTime endDate = new DateTime(now.Year, 12, 31);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"去年"
        private static DateTime[] ParseLastYear()
        {
            DateTime now = DateTime.Now;
            DateTime startDate = new DateTime(now.Year - 1, 1, 1);
            DateTime endDate = new DateTime(now.Year - 1, 12, 31);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"明年"
        private static DateTime[] ParseNextYear()
        {
            DateTime now = DateTime.Now;
            DateTime startDate = new DateTime(now.Year + 1, 1, 1);
            DateTime endDate = new DateTime(now.Year + 1, 12, 31);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"上个季度"
        private static DateTime[] ParseLastQuarter()
        {
            DateTime now = DateTime.Now;
            int currentQuarter = (now.Month - 1) / 3 + 1;
            int year = now.Year;
            if (currentQuarter == 1)
            {
                year -= 1;
                currentQuarter = 4;
            }
            else
            {
                currentQuarter -= 1;
            }
            DateTime startDate = new DateTime(year, (currentQuarter - 1) * 3 + 1, 1);
            DateTime endDate = startDate.AddMonths(3).AddDays(-1);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"下个季度"
        private static DateTime[] ParseNextQuarter()
        {
            DateTime now = DateTime.Now;
            int currentQuarter = (now.Month - 1) / 3 + 1;
            int year = now.Year;
            if (currentQuarter == 4)
            {
                year += 1;
                currentQuarter = 1;
            }
            else
            {
                currentQuarter += 1;
            }
            DateTime startDate = new DateTime(year, (currentQuarter - 1) * 3 + 1, 1);
            DateTime endDate = startDate.AddMonths(3).AddDays(-1);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"本季度"
        private static DateTime[] ParseThisQuarter()
        {
            DateTime now = DateTime.Now;
            int currentQuarter = (now.Month - 1) / 3 + 1;
            DateTime startDate = new DateTime(now.Year, (currentQuarter - 1) * 3 + 1, 1);
            DateTime endDate = startDate.AddMonths(3).AddDays(-1);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"上周"
        private static DateTime[] ParseLastWeek()
        {
            DateTime now = DateTime.Now;
            DateTime startDate = DateTime.Today.AddDays(-(int)DateTime.Today.DayOfWeek - 7);
            DateTime endDate = startDate.AddDays(6);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"下周"
        private static DateTime[] ParseNextWeek()
        {
            DateTime now = DateTime.Now;
            DateTime startDate = DateTime.Today.AddDays(-(int)DateTime.Today.DayOfWeek + 7);
            DateTime endDate = startDate.AddDays(6);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"上个财年"
        private static DateTime[] ParseLastFiscalYear()
        {
            DateTime now = DateTime.Now;
            int currentYear = now.Month >= 4 ? now.Year : now.Year - 1;
            DateTime startDate = new DateTime(currentYear - 1, 4, 1);
            DateTime endDate = new DateTime(currentYear, 3, 31);
            return new DateTime[] { startDate, endDate };
        }

        // 解析"今年至今"
        private static DateTime[] ParseYearToDate()
        {
            DateTime now = DateTime.Now;
            DateTime startDate = new DateTime(now.Year, 1, 1);
            DateTime endDate = now;
            return new DateTime[] { startDate, endDate };
        }

        // 解析"上个季度至今"
        private static DateTime[] ParseLastQuarterToDate()
        {
            DateTime now = DateTime.Now;
            int currentQuarter = (now.Month - 1) / 3 + 1;
            int year = now.Year;
            if (currentQuarter == 1)
            {
                year -= 1;
                currentQuarter = 4;
            }
            else
            {
                currentQuarter -= 1;
            }
            DateTime startDate = new DateTime(year, (currentQuarter - 1) * 3 + 1, 1);
            return new DateTime[] { startDate, now };
        }

        // 判断输入的句子中是否包含节假日
        public static bool ContainsAppointDay(string input)
        {
            // 使用正则表达式来匹配节假日
            Regex regex = new Regex(string.Join("|", timeParsingRules.Keys));
            return regex.IsMatch(input);
        }

        // 如果包含节假日，返回匹配的节假日名称
        public static string GetAppointDayName(string input)
        {
            Regex regex = new Regex(string.Join("|", timeParsingRules.Keys));
            Match match = regex.Match(input);
            return match.Success ? match.Value : "未找到指定日期";
        }


        // 定义时间解析规则表
        public static Dictionary<string, Func<int, DateTime[]>> holidayParsingRules = new Dictionary<string, Func<int, DateTime[]>>
        {
            { "元旦", ParseNewYear },
            { "暑期", ParseSummerVacation },
            { "春运", ParseSpringFestivalTravelRush },
            { "春节", ParseChineseNewYear },
            { "清明节", ParseQingMing },
            { "劳动节", ParseLaborDay },
            { "端午节", ParseDragonBoatFestival },
            { "中秋节", ParseMidAutumnFestival },
            { "国庆节", ParseNationalDay }
        };

        // 通用解析函数，解析节假日
        public static string ParseHoliday(string holidayPhrase, int year)
        {
            foreach (var rule in holidayParsingRules)
            {
                if (holidayPhrase.Contains(rule.Key))
                {
                    var dateRange = rule.Value.Invoke(year);
                    return $"{year}年{rule.Key}的日期: 起始日期: {dateRange[0]:yyyy-MM-dd}, 结束日期: {dateRange[1]:yyyy-MM-dd}";
                }
            }
            return "无法解析该节假日短语";
        }

        // 解析元旦（1月1日）
        private static DateTime[] ParseNewYear(int year)
        {
            DateTime newYearDay = new DateTime(year, 1, 1);
            return new DateTime[] { newYearDay, newYearDay };
        }

        // 解析暑期（7月1日 - 8月31日）
        private static DateTime[] ParseSummerVacation(int year)
        {
            DateTime startDate = new DateTime(year, 7, 1);
            DateTime endDate = new DateTime(year, 8, 31);
            return new DateTime[] { startDate, endDate };
        }

        // 解析春运（春节前15天到春节后25天）
        private static DateTime[] ParseSpringFestivalTravelRush(int year)
        {
            DateTime chineseNewYear = GetLunarHoliday(year, 1, 1); // 农历正月初一
            DateTime startDate = chineseNewYear.AddDays(-15); // 春运开始日期
            DateTime endDate = chineseNewYear.AddDays(25); // 春运结束日期
            return new DateTime[] { startDate, endDate };
        }

        // 解析春节（农历正月初一）
        private static DateTime[] ParseChineseNewYear(int year)
        {
            DateTime chineseNewYear = GetLunarHoliday(year, 1, 1); // 农历正月初一
            return new DateTime[] { chineseNewYear, chineseNewYear };
        }

        // 解析清明节（公历4月4日至6日）
        private static DateTime[] ParseQingMing(int year)
        {
            DateTime qingmingFestival = new DateTime(year, 4, 4); // 清明节默认4月4日
            return new DateTime[] { qingmingFestival, qingmingFestival };
        }

        // 解析劳动节（公历5月1日）
        private static DateTime[] ParseLaborDay(int year)
        {
            DateTime laborDay = new DateTime(year, 5, 1);
            return new DateTime[] { laborDay, laborDay };
        }

        // 解析端午节（农历5月初五）
        private static DateTime[] ParseDragonBoatFestival(int year)
        {
            DateTime dragonBoatFestival = GetLunarHoliday(year, 5, 5); // 农历5月初五
            return new DateTime[] { dragonBoatFestival, dragonBoatFestival };
        }

        // 解析中秋节（农历8月15日）
        private static DateTime[] ParseMidAutumnFestival(int year)
        {
            DateTime midAutumnFestival = GetLunarHoliday(year, 8, 15); // 农历8月15日
            return new DateTime[] { midAutumnFestival, midAutumnFestival };
        }

        // 解析国庆节（公历10月1日）
        private static DateTime[] ParseNationalDay(int year)
        {
            DateTime nationalDay = new DateTime(year, 10, 1);
            return new DateTime[] { nationalDay, nationalDay };
        }

        // 获取农历节日对应的公历日期
        private static DateTime GetLunarHoliday(int year, int lunarMonth, int lunarDay)
        {
            ChineseLunisolarCalendar lunarCalendar = new ChineseLunisolarCalendar();
            DateTime chineseNewYear = lunarCalendar.ToDateTime(year, lunarMonth, lunarDay, 0, 0, 0, 0);
            return chineseNewYear;
        }
    }
}