Пример #1
0
        }         // SelectPeriod

        // ----------------------------------------------------------------------
        private void Collect(CollectType collectType)
        {
            // filter
            CalendarPeriodCollectorFilter filter = new CalendarPeriodCollectorFilter();

            foreach (int year in yearFilter.SelectedItems)
            {
                filter.Years.Add(year);
            }
            foreach (YearMonth yearMonth in yearMonthFilter.SelectedItems)
            {
                filter.Months.Add(yearMonth);
            }
            foreach (int day in dayFilter.SelectedItems)
            {
                filter.Days.Add(day);
            }
            foreach (DayOfWeek dayOfWeek in dayOfWeekFilter.SelectedItems)
            {
                filter.WeekDays.Add(dayOfWeek);
            }

            // period limits
            TimeRange workingTimeRange = WorkingTimeRange;

            if (workingTimeRange == null)
            {
                CollectorStatus = "Invalid Working Time Range!";
                return;
            }

            // collect months
            YearMonth?collectMonthStart = CollectMonthStart;
            YearMonth?collectMonthEnd   = CollectMonthEnd;

            if (collectMonthStart.HasValue && collectMonthEnd.HasValue)
            {
                if (collectMonthEnd.Value < collectMonthStart.Value)
                {
                    CollectorStatus = "Invalid Collecting Periods Months!";
                    return;
                }
                filter.CollectingMonths.Add(new MonthRange(collectMonthStart.Value, collectMonthEnd.Value));
            }

            // collect day
            int?collectDayStart = CollectDayStart;
            int?collectDayEnd   = CollectDayEnd;

            if (collectDayStart.HasValue && collectDayEnd.HasValue)
            {
                if (collectDayEnd.Value < collectDayStart.Value)
                {
                    CollectorStatus = "Invalid Collecting Periods Days!";
                    return;
                }
                filter.CollectingDays.Add(new DayRange(collectDayStart.Value, collectDayEnd.Value));
            }

            // collect hour
            int?collectHourStart = CollectHourStart;
            int?collectHourEnd   = CollectHourEnd;

            if (collectHourStart.HasValue && collectHourEnd.HasValue)
            {
                if (collectHourEnd.Value < collectHourStart.Value)
                {
                    CollectorStatus = "Invalid Collecting Periods Hours!";
                    return;
                }
                filter.CollectingHours.Add(new HourRange(collectHourStart.Value, collectHourEnd.Value));
            }

            StringBuilder status = new StringBuilder();

            // collector
            string collectContext = string.Empty;

            TimePeriod.CalendarPeriodCollector collector =
                new TimePeriod.CalendarPeriodCollector(filter, workingTimeRange);
            switch (collectType)
            {
            case CollectType.Year:
                collectContext = "year";
                collector.CollectYears();
                break;

            case CollectType.Month:
                collectContext = "month";
                collector.CollectMonths();
                break;

            case CollectType.Day:
                collectContext = "day";
                collector.CollectDays();
                break;

            case CollectType.Hour:
                collectContext = "hour";
                collector.CollectHours();
                break;
            }

            collectedPeriods.Clear();
            if (collector.Periods.Count == 0)
            {
                status.Append(string.Format("no {0} periods found", collectContext));
            }
            else if (collector.Periods.Count > maxPeriodCount)
            {
                status.Append(string.Format("{0} {1} periods found, a maximum of {2} periods can be displayed",
                                            collector.Periods.Count, collectContext, maxPeriodCount));
            }
            else
            {
                foreach (ITimePeriod timePeriod in collector.Periods)
                {
                    collectedPeriods.Add(timePeriod);
                }
                status.Append(string.Format("{0} {1} periods found", collectedPeriods.Count, collectContext));
            }

            CollectorStatus    = status.ToString();
            LastCollectionDate = DateTime.Now;

            if (CopyToClipboard)
            {
                collectedPeriods.CopyToClipboard();
            }
        }         // Collect
Пример #2
0
        // ----------------------------------------------------------------------
        private void Collect( CollectType collectType )
        {
            // filter
            CalendarPeriodCollectorFilter filter = new CalendarPeriodCollectorFilter();
            foreach ( int year in yearFilter.SelectedItems )
            {
                filter.Years.Add( year );
            }
            foreach ( YearMonth yearMonth in yearMonthFilter.SelectedItems )
            {
                filter.Months.Add( yearMonth );
            }
            foreach ( int day in dayFilter.SelectedItems )
            {
                filter.Days.Add( day );
            }
            foreach ( DayOfWeek dayOfWeek in dayOfWeekFilter.SelectedItems )
            {
                filter.WeekDays.Add( dayOfWeek );
            }

            // period limits
            TimeRange workingTimeRange = WorkingTimeRange;
            if ( workingTimeRange == null )
            {
                CollectorStatus = "Invalid Working Time Range!";
                return;
            }

            // collect months
            YearMonth? collectMonthStart = CollectMonthStart;
            YearMonth? collectMonthEnd = CollectMonthEnd;
            if ( collectMonthStart.HasValue && collectMonthEnd.HasValue )
            {
                if ( collectMonthEnd.Value < collectMonthStart.Value )
                {
                    CollectorStatus = "Invalid Collecting Periods Months!";
                    return;
                }
                filter.CollectingMonths.Add( new MonthRange( collectMonthStart.Value, collectMonthEnd.Value ) );
            }

            // collect day
            int? collectDayStart = CollectDayStart;
            int? collectDayEnd = CollectDayEnd;
            if ( collectDayStart.HasValue && collectDayEnd.HasValue )
            {
                if ( collectDayEnd.Value < collectDayStart.Value )
                {
                    CollectorStatus = "Invalid Collecting Periods Days!";
                    return;
                }
                filter.CollectingDays.Add( new DayRange( collectDayStart.Value, collectDayEnd.Value ) );
            }

            // collect hour
            int? collectHourStart = CollectHourStart;
            int? collectHourEnd = CollectHourEnd;
            if ( collectHourStart.HasValue && collectHourEnd.HasValue )
            {
                if ( collectHourEnd.Value < collectHourStart.Value )
                {
                    CollectorStatus = "Invalid Collecting Periods Hours!";
                    return;
                }
                filter.CollectingHours.Add( new HourRange( collectHourStart.Value, collectHourEnd.Value ) );
            }

            StringBuilder status = new StringBuilder();

            // collector
            string collectContext = string.Empty;
            TimePeriod.CalendarPeriodCollector collector =
                new TimePeriod.CalendarPeriodCollector( filter, workingTimeRange );
            switch ( collectType )
            {
                case CollectType.Year:
                    collectContext = "year";
                    collector.CollectYears();
                    break;
                case CollectType.Month:
                    collectContext = "month";
                    collector.CollectMonths();
                    break;
                case CollectType.Day:
                    collectContext = "day";
                    collector.CollectDays();
                    break;
                case CollectType.Hour:
                    collectContext = "hour";
                    collector.CollectHours();
                    break;
            }

            collectedPeriods.Clear();
            if ( collector.Periods.Count == 0 )
            {
                status.Append( string.Format( "no {0} periods found", collectContext ) );
            }
            else if ( collector.Periods.Count > maxPeriodCount )
            {
                status.Append( string.Format( "{0} {1} periods found, a maximum of {2} periods can be displayed",
                                                                            collector.Periods.Count, collectContext, maxPeriodCount ) );
            }
            else
            {
                foreach ( ITimePeriod timePeriod in collector.Periods )
                {
                    collectedPeriods.Add( timePeriod );
                }
                status.Append( string.Format( "{0} {1} periods found", collectedPeriods.Count, collectContext ) );
            }

            CollectorStatus = status.ToString();
            LastCollectionDate = DateTime.Now;

            if ( CopyToClipboard )
            {
                collectedPeriods.CopyToClipboard();
            }
        }