Example #1
0
        }         // IntersectsYear

        // ----------------------------------------------------------------------
        public void GetDaysOfPastQuarter(DateTime moment, out DateTime firstDay, out DateTime lastDay)
        {
            TimeCalendar calendar = new TimeCalendar(
                new TimeCalendarConfig {
                YearBaseMonth = YearMonth.October
            });
            Quarter quarter     = new Quarter(moment, calendar);
            Quarter pastQuarter = quarter.GetPreviousQuarter();

            firstDay = pastQuarter.FirstDayStart;
            lastDay  = pastQuarter.LastDayStart;
        }         // GetDaysOfPastQuarter
        // ----------------------------------------------------------------------
        public static void ShowAll(int periodCount, int startYear, YearQuarter yearQuarter, TimeCalendarConfig calendarConfig)
        {
            WriteLine("Input: count={0}, year={1}, quarter={2}", periodCount, startYear, yearQuarter);
            WriteLine();

            QuarterTimeRange quarterTimeRange;

            if (periodCount == 1)
            {
                Quarter quarter = new Quarter(startYear, yearQuarter, new TimeCalendar(calendarConfig));
                quarterTimeRange = quarter;

                Quarter previousQuarter = quarter.GetPreviousQuarter();
                Quarter nextQuarter     = quarter.GetNextQuarter();

                ShowQuarter(quarter);
                ShowCompactQuarter(previousQuarter, "Previous Quarter");
                ShowCompactQuarter(nextQuarter, "Next Quarter");
                WriteLine();
            }
            else
            {
                Quarters quarters = new Quarters(startYear, yearQuarter, periodCount, new TimeCalendar(calendarConfig));
                quarterTimeRange = quarters;

                ShowQuarters(quarters);
                WriteLine();

                foreach (Quarter quarter in quarters.GetQuarters())
                {
                    ShowCompactQuarter(quarter);
                }
                WriteLine();
            }

            foreach (Month month in quarterTimeRange.GetMonths())
            {
                MonthDemo.ShowCompactMonth(month);
            }
            WriteLine();
        }         // ShowAll
        public void CalendarYearQuarterTest()
        {
            int          currentYear = ClockProxy.Clock.Now.Year;
            TimeCalendar calendar    = TimeCalendar.New(TimeSpan.Zero, TimeSpan.Zero);

            Quarter current = new Quarter(currentYear, YearQuarter.First);

            Assert.Equal(current.GetNextQuarter().GetNextQuarter().GetNextQuarter().GetNextQuarter().YearQuarter, current.YearQuarter);
            Assert.Equal(current.GetPreviousQuarter().GetPreviousQuarter().GetPreviousQuarter().GetPreviousQuarter().YearQuarter, current.YearQuarter);

            Quarter q1 = new Quarter(currentYear, YearQuarter.First, calendar);

            Assert.True(q1.IsReadOnly);
            Assert.Equal(YearQuarter.First, q1.YearQuarter);
            Assert.Equal(q1.Start, new DateTime(currentYear, TimeSpec.FirstQuarterMonthIndex, 1));
            Assert.Equal(q1.End, new DateTime(currentYear, TimeSpec.SecondQuarterMonthIndex, 1));

            Quarter q2 = new Quarter(currentYear, YearQuarter.Second, calendar);

            Assert.True(q2.IsReadOnly);
            Assert.Equal(YearQuarter.Second, q2.YearQuarter);
            Assert.Equal(q2.Start, new DateTime(currentYear, TimeSpec.SecondQuarterMonthIndex, 1));
            Assert.Equal(q2.End, new DateTime(currentYear, TimeSpec.ThirdQuarterMonthIndex, 1));

            Quarter q3 = new Quarter(currentYear, YearQuarter.Third, calendar);

            Assert.True(q3.IsReadOnly);
            Assert.Equal(YearQuarter.Third, q3.YearQuarter);
            Assert.Equal(q3.Start, new DateTime(currentYear, TimeSpec.ThirdQuarterMonthIndex, 1));
            Assert.Equal(q3.End, new DateTime(currentYear, TimeSpec.FourthQuarterMonthIndex, 1));

            Quarter q4 = new Quarter(currentYear, YearQuarter.Fourth, calendar);

            Assert.True(q4.IsReadOnly);
            Assert.Equal(YearQuarter.Fourth, q4.YearQuarter);
            Assert.Equal(q4.Start, new DateTime(currentYear, TimeSpec.FourthQuarterMonthIndex, 1));
            Assert.Equal(q4.End, new DateTime(currentYear + 1, TimeSpec.FirstQuarterMonthIndex, 1));
        }         // CalendarYearQuarterTest
        public void QuarterMomentTest()
        {
            Quarter quarter = new Quarter(2008, YearQuarter.First, TimeCalendar.New(TimeSpan.Zero, TimeSpan.Zero));

            Assert.True(quarter.IsReadOnly);
            Assert.Equal(2008, quarter.BaseYear);
            Assert.Equal(YearQuarter.First, quarter.YearQuarter);
            Assert.Equal(quarter.Start, new DateTime(2008, TimeSpec.FirstQuarterMonthIndex, 1));
            Assert.Equal(quarter.End, new DateTime(2008, TimeSpec.SecondQuarterMonthIndex, 1));

            Quarter previous = quarter.GetPreviousQuarter();

            Assert.Equal(2007, previous.BaseYear);
            Assert.Equal(YearQuarter.Fourth, previous.YearQuarter);
            Assert.Equal(previous.Start, new DateTime(2007, TimeSpec.FourthQuarterMonthIndex, 1));
            Assert.Equal(previous.End, new DateTime(2008, TimeSpec.FirstQuarterMonthIndex, 1));

            Quarter next = quarter.GetNextQuarter();

            Assert.Equal(2008, next.BaseYear);
            Assert.Equal(YearQuarter.Second, next.YearQuarter);
            Assert.Equal(next.Start, new DateTime(2008, TimeSpec.SecondQuarterMonthIndex, 1));
            Assert.Equal(next.End, new DateTime(2008, TimeSpec.ThirdQuarterMonthIndex, 1));
        }         // QuarterMomentTest
        }         // NotifyPropertyChanged

        // ----------------------------------------------------------------------
        private void UpdateSelectedPeriodInfo()
        {
            TimeCalendar timeCalendar = TimeCalendar.New(SelectedYearBaseMonth);

            switch (SelectedPeriodMode)
            {
            case TimePeriodMode.Year:
                Year year = new Year(WorkingDate, timeCalendar);
                periodInfo.Clear();
                periodInfo.AddItem("Year", year);
                periodInfo.AddItem("YearBaseMonth", year.YearBaseMonth);
                periodInfo.AddItem("IsCalendarYear", year.IsCalendarYear);
                periodInfo.AddItem("StartYear", year.StartYear);
                periodInfo.AddItem("FirstDayStart", year.FirstDayStart);
                periodInfo.AddItem("LastDayStart", year.LastDayStart);
                periodInfo.AddItem("LastMonthStart", year.LastMonthStart);
                periodInfo.AddItem("YearName", year.YearName);
                periodInfo.AddSection("Previous/Next");
                periodInfo.AddItem("Previous", year.GetPreviousYear());
                periodInfo.AddItem("Next", year.GetNextYear());
                periodInfo.AddSubitems("Halfyears", year.GetHalfyears());
                periodInfo.AddSubitems("Quarters", year.GetQuarters());
                periodInfo.AddSubitems("Months", year.GetMonths());
                SelectedPeriodInfo = periodInfo.ToString();
                break;

            case TimePeriodMode.Halfyear:
                Halfyear halfyear = new Halfyear(WorkingDate, timeCalendar);
                periodInfo.Clear();
                periodInfo.AddItem("Halfyear", halfyear);
                periodInfo.AddItem("YearBaseMonth", halfyear.YearBaseMonth);
                periodInfo.AddItem("StartMonth", halfyear.StartMonth);
                periodInfo.AddItem("Year", halfyear.Year);
                periodInfo.AddItem("YearHalfyear", halfyear.YearHalfyear);
                periodInfo.AddItem("IsCalendarHalfyear", halfyear.IsCalendarHalfyear);
                periodInfo.AddItem("MultipleCalendarYears", halfyear.MultipleCalendarYears);
                periodInfo.AddItem("HalfyearName", halfyear.HalfyearName);
                periodInfo.AddItem("HalfyearOfYearName", halfyear.HalfyearOfYearName);
                periodInfo.AddItem("LastDayStart", halfyear.LastDayStart);
                periodInfo.AddItem("LastMonthStart", halfyear.LastMonthStart);
                periodInfo.AddSection("Previous/Next");
                periodInfo.AddItem("Previousr", halfyear.GetPreviousHalfyear());
                periodInfo.AddItem("Next", halfyear.GetNextHalfyear());
                periodInfo.AddSubitems("Quarters", halfyear.GetQuarters());
                periodInfo.AddSubitems("Months", halfyear.GetMonths());
                SelectedPeriodInfo = periodInfo.ToString();
                break;

            case TimePeriodMode.Quarter:
                Quarter quarter = new Quarter(WorkingDate, timeCalendar);
                periodInfo.Clear();
                periodInfo.AddItem("Quarter", quarter);
                periodInfo.AddItem("YearBaseMonth", quarter.YearBaseMonth);
                periodInfo.AddItem("StartMonth", quarter.StartMonth);
                periodInfo.AddItem("Year", quarter.Year);
                periodInfo.AddItem("YearQuarter", quarter.YearQuarter);
                periodInfo.AddItem("IsCalendarQuarter", quarter.IsCalendarQuarter);
                periodInfo.AddItem("MultipleCalendarYears", quarter.MultipleCalendarYears);
                periodInfo.AddItem("QuarterName", quarter.QuarterName);
                periodInfo.AddItem("QuarterOfYearName", quarter.QuarterOfYearName);
                periodInfo.AddItem("LastDayStart", quarter.FirstDayStart);
                periodInfo.AddItem("LastMonthStart", quarter.LastDayStart);
                periodInfo.AddSection("Previous/Next");
                periodInfo.AddItem("Previous", quarter.GetPreviousQuarter());
                periodInfo.AddItem("Next", quarter.GetNextQuarter());
                periodInfo.AddSubitems("Months", quarter.GetMonths());
                SelectedPeriodInfo = periodInfo.ToString();
                break;

            case TimePeriodMode.Month:
                Month month = new Month(WorkingDate, timeCalendar);
                periodInfo.Clear();
                periodInfo.AddItem("Month", month);
                periodInfo.AddItem("YearBaseMonth", month.YearMonth);
                periodInfo.AddItem("Year", month.Year);
                periodInfo.AddItem("DaysInMonth", month.DaysInMonth);
                periodInfo.AddItem("MonthName", month.MonthName);
                periodInfo.AddItem("MonthOfYearName", month.MonthOfYearName);
                periodInfo.AddItem("LastDayStart", month.FirstDayStart);
                periodInfo.AddItem("LastMonthStart", month.LastDayStart);
                periodInfo.AddSection("Previous/Next");
                periodInfo.AddItem("Previous", month.GetPreviousMonth());
                periodInfo.AddItem("Next", month.GetNextMonth());
                periodInfo.AddSubitems("Days", month.GetDays());
                SelectedPeriodInfo = periodInfo.ToString();
                break;

            case TimePeriodMode.Week:
                Week week = new Week(WorkingDate, timeCalendar);
                periodInfo.Clear();
                periodInfo.AddItem("Week", week);
                periodInfo.AddItem("MultipleCalendarYears", week.MultipleCalendarYears);
                periodInfo.AddItem("FirstDayStart", week.FirstDayStart);
                periodInfo.AddItem("FirstDayOfWeek", week.FirstDayOfWeek);
                periodInfo.AddItem("LastDayStart", week.LastDayStart);
                periodInfo.AddItem("LastDayOfWeek", week.LastDayOfWeek);
                periodInfo.AddItem("WeekOfYear", week.WeekOfYear);
                periodInfo.AddItem("WeekOfYearName", week.WeekOfYearName);
                periodInfo.AddSection("Previous/Next");
                periodInfo.AddItem("Previous", week.GetPreviousWeek());
                periodInfo.AddItem("Next", week.GetNextWeek());
                periodInfo.AddSubitems("Days", week.GetDays());
                SelectedPeriodInfo = periodInfo.ToString();
                break;

            case TimePeriodMode.Day:
                Day day = new Day(WorkingDate, timeCalendar);
                periodInfo.Clear();
                periodInfo.AddItem("Day", day);
                periodInfo.AddItem("Year", day.Year);
                periodInfo.AddItem("FirstDayStart", day.FirstDayStart);
                periodInfo.AddItem("Month", day.Month);
                periodInfo.AddItem("DayValue", day.DayValue);
                periodInfo.AddItem("DayOfWeek", day.DayOfWeek);
                periodInfo.AddItem("DayName", day.DayName);
                periodInfo.AddItem("FirstHourStart", day.FirstHourStart);
                periodInfo.AddItem("LastHourStart", day.LastHourStart);
                periodInfo.AddSection("Previous/Next");
                periodInfo.AddItem("Previous", day.GetPreviousDay());
                periodInfo.AddItem("Next", day.GetNextDay());
                periodInfo.AddSubitems("Hours", day.GetHours());
                SelectedPeriodInfo = periodInfo.ToString();
                break;

            case TimePeriodMode.Hour:
                Hour hour = new Hour(WorkingDate, timeCalendar);
                periodInfo.Clear();
                periodInfo.AddItem("Hour", hour);
                periodInfo.AddItem("Year", hour.Year);
                periodInfo.AddItem("Month", hour.Month);
                periodInfo.AddItem("Day", hour.Day);
                periodInfo.AddItem("HourValue", hour.HourValue);
                periodInfo.AddItem("FirstMinuteStart", hour.FirstMinuteStart);
                periodInfo.AddItem("LastMinuteStart", hour.LastMinuteStart);
                periodInfo.AddSection("Previous/Next");
                periodInfo.AddItem("Previous", hour.GetPreviousHour());
                periodInfo.AddItem("Next", hour.GetNextHour());
                periodInfo.AddSubitems("Minutes", hour.GetMinutes());
                SelectedPeriodInfo = periodInfo.ToString();
                break;

            case TimePeriodMode.Minute:
                Minute minute = new Minute(WorkingDate, timeCalendar);
                periodInfo.Clear();
                periodInfo.AddItem("Minute", minute);
                periodInfo.AddItem("Year", minute.Year);
                periodInfo.AddItem("Month", minute.Month);
                periodInfo.AddItem("Day", minute.Day);
                periodInfo.AddItem("Hour", minute.Hour);
                periodInfo.AddItem("MinuteValue", minute.MinuteValue);
                periodInfo.AddSection("Previous/Next");
                periodInfo.AddItem("Previous", minute.GetPreviousMinute());
                periodInfo.AddItem("Next", minute.GetNextMinute());
                SelectedPeriodInfo = periodInfo.ToString();
                break;
            }
        }         // UpdateSelectedPeriodInfo