public DateFilter(Point point)
        {
            InitializeComponent();
            DateRange = new DateRange();
            this.Location = point;
            panelDtp.Visible = false;
            panelMonth.Visible = false;

            cbFromMonth.SelectedIndex = 0;
            cbToMonth.SelectedIndex = 0;

            for (int i = DateTime.Now.Year - 5; i < DateTime.Now.Year + 5; i++)
            {
                cbFromYear.Items.Add(i);
                cbToYear.Items.Add(i);
            }
            cbFromYear.SelectedIndex = 0;
            cbToYear.SelectedIndex = 0;
            cbDateFilterType.SelectedIndex = 0;
            cbFromYear.SelectedIndexChanged += new System.EventHandler(cbFromYear_SelectedIndexChanged);
            cbToYear.SelectedIndexChanged += new System.EventHandler(cbToYear_SelectedIndexChanged);

            this.cbToMonth.SelectedIndexChanged += new System.EventHandler(this.cbToMonth_SelectedIndexChanged);
            this.cbFromMonth.SelectedIndexChanged += new System.EventHandler(this.cbFromMonth_SelectedIndexChanged);
        }

        private object GenerateUsageReport(IUnitOfWork uow, DateRange dateRange, int start,
            int length, out int count)
        {
            _dataUrlMappings = new Dictionary<string, string>();
            _dataUrlMappings.Add("BookingRequest", "/Dashboard/Index/");
            _dataUrlMappings.Add("Email", "/Dashboard/Index/");
            _dataUrlMappings.Add("User", "/User/Details?userID=");


            var factDO = uow.FactRepository.GetQuery().WhereInDateRange(e => e.CreateDate, dateRange);

            count = factDO.Count();

            return factDO
                .OrderByDescending(e => e.CreateDate)
                .Skip(start)
                .Take(length)
                .AsEnumerable()
                .Select(
                    f => new
                        {
                            PrimaryCategory = f.PrimaryCategory,
                            SecondaryCategory = f.SecondaryCategory,
                            Activity = f.Activity,
                            Status = f.Status,
                            Data = AddClickability(f.Data),
                            CreateDate = f.CreateDate.ToString(DateStandardFormat),
                        })
                .ToList();

        }

        public static double ItemCount(CalendarAppointmentItem currentApp, UIElementCollection children)
        {
            double count = 0;
            foreach (UIElement child in children)
            {
                if (child is CalendarAppointmentItem)
                {
                    var currentChild = child as CalendarAppointmentItem;

                    var cStart = currentApp.GetValue(TimeSlotPanel.StartTimeProperty) as DateTime?;
                    var cEnd = currentApp.GetValue(TimeSlotPanel.EndTimeProperty) as DateTime?;
                    var toTest = new DateRange(cStart.Value, cEnd.Value);

                    var aStart = currentChild.GetValue(TimeSlotPanel.StartTimeProperty) as DateTime?;
                    var aEnd = currentChild.GetValue(TimeSlotPanel.EndTimeProperty) as DateTime?;
                    var current = new DateRange(aStart.Value, aEnd.Value);

                    if (toTest.Overlaps(current))
                    {
                        count++;
                    }
                }
            }
            return count;
        }

        public MyViewModel()
        {
            var date = DateTime.Now;
            var ganttAPI = new GanttTask(date, date.AddDays(2), "Design public API") { Description = "Description: Design public API" };

            var ganttRendering = new GanttTask(date.AddDays(2).AddHours(8), date.AddDays(4), "Gantt Rendering") { Description = "Description: Gantt Rendering" };

            var ganttDemos = new GanttTask(date.AddDays(4.5), date.AddDays(7), "Gantt Demos") { Description = "Description: Gantt Demos" };

            var milestone = new GanttTask(date.AddDays(7), date.AddDays(7).AddHours(1), "Review") { Description = "Review", IsMilestone = true };

            ganttRendering.Dependencies.Add(new Dependency { FromTask = ganttAPI });
            ganttDemos.Dependencies.Add(new Dependency { FromTask = ganttRendering });

            var iterationTask = new GanttTask(date, date.AddDays(7), "Iteration 1")
            {
                Children = { ganttAPI, ganttRendering, ganttDemos, milestone }
            };

            this.tasks = new ObservableCollection<GanttTask>() { iterationTask };
            this.visibleTime = new DateRange(date.AddDays(-1), date.AddDays(9));
            this.timeLineDeadlineBehavior = new TimeLineDeadlineBehavior();

            this.ProjectDeadline = date.AddDays(8);
        }

        public void StartDateHaveToBeEarlierThanEndDate_ArgumentException()
        {
            DateTime startDate = DateTime.Now.AddMonths(months: 2);
            DateTime endDate = DateTime.Now.AddMonths(months: 1);

            DateRange range = new DateRange(startDate, endDate);
        }

 public ImportConsent(Guid notificationId, DateRange consentRange, string conditions, Guid userId)
 {
     ConsentRange = consentRange;
     Conditions = conditions;
     UserId = userId;
     NotificationId = notificationId;
 }

 protected DateTime GetRangeStart(DateRange range)
 {
     switch (range) {
         case DateRange.Today:
             return DateTime.Now.Date;
         case DateRange.Last24Hours:
             return DateTime.Now.AddDays(-1);
         case DateRange.ThisWeek:
             //TODO #################
             int diff = DateTime.Now.DayOfWeek - DayOfWeek.Monday;
             if (diff < 0){
                 diff += 7;
             }
             return DateTime.Now.AddDays(-1 * diff).Date;
         case DateRange.Last7Days:
             return DateTime.Now.Date.AddDays(-7);
         case DateRange.ThisMonth:
             return new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
         case DateRange.Last30Days:
             return new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day).AddDays(-30);
         case DateRange.ThisYear:
             return new DateTime(DateTime.Now.Year, 1, 1);
         case DateRange.LastYear:
             return new DateTime(DateTime.Now.Year, 1, 1).AddYears(-1);
         case DateRange.All:
             return new DateTime(1790, 1, 1);
         case DateRange.LastMonth:
             return new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1).AddMonths(-1);
         default:
             break;
     }
     return DateTime.Now;
 }

 public object Generate(IUnitOfWork uow, DateRange dateRange, string type, int start,
     int length, out int recordcount)
 {
     recordcount = 0;
     switch (type)
     {
         case "alllogs":
             return ShowAllLogs(uow, dateRange, start,
      length, out recordcount);
         case "usage":
             return GenerateUsageReport(uow, dateRange, start,
      length, out recordcount);
         case "incident":
             return ShowAllIncidents(uow, dateRange, start,
     length, out recordcount);
         case "fiveRecentIncident":
             return ShowMostRecent5Incidents(uow, out recordcount);
         case "showBookerThroughput":
             return ShowBookerThroughput(uow, dateRange, start,
      length, out recordcount);
         case "showBRResponsiveness":
             return ShowBRResponsiveness(uow, dateRange, start,
      length, out recordcount);
     }
     return this;
 }

        public void Constructor_NullEffectiveDate_Succeeds()
        {
            DateTime? effectiveDate = null;
            DateTime expirationDate = new DateTime ( 2000, 1, 1 );

            DateRange dateRange = new DateRange ( effectiveDate, expirationDate );
        }

 protected DateTime GetRangeEnd(DateRange range)
 {
     switch (range) {
         case DateRange.Today:
             return DateTime.Now;
         case DateRange.Last24Hours:
             return DateTime.Now;
         case DateRange.ThisWeek:
             return DateTime.Now;
         case DateRange.Last7Days:
             return DateTime.Now;
         case DateRange.ThisMonth:
             return DateTime.Now;
         case DateRange.Last30Days:
             return DateTime.Now;
         case DateRange.ThisYear:
             return DateTime.Now;
         case DateRange.LastYear:
             return new DateTime(DateTime.Now.Year, 1, 1);
         case DateRange.All:
             return new DateTime(2030, 1, 1);
         case DateRange.LastMonth:
             return new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1).AddMinutes(-1);
         default:
             break;
     }
     return DateTime.Now;
 }

        public void Constructor_LaterThanExpiration_ThrowsException()
        {
            DateTime effectiveDate = new DateTime ( 2000, 1, 2 );
            DateTime expirationDate = new DateTime ( 2000, 1, 1 );

            DateRange dateRange = new DateRange ( effectiveDate, expirationDate );
        }

        public void EqualityTest()
        {
            DateRange sd = new DateRange(d1, d1);
            DateRange sd2 = new DateRange(d1, d1);
            Assert.AreEqual(sd, sd2);

            sd = new DateRange(d1, d2);
            sd2 = new DateRange(d1, d1);
            Assert.AreNotEqual(sd, sd2);

            sd = new DateRange(null, d1);
            sd2 = new DateRange(null, d1);
            Assert.AreEqual(sd, sd2);

            sd = new DateRange(d1, null);
            sd2 = new DateRange(d1, null);
            Assert.AreEqual(sd, sd2);

            sd = new DateRange(null, d1);
            sd2 = new DateRange(d1, null);
            Assert.AreNotEqual(sd, sd2);

            sd = new DateRange(null, null);
            sd2 = new DateRange(d1, null);
            Assert.AreNotEqual(sd, sd2);
        }

        public void Map()
        {
            // Arrange
            var start = new DateTime(2010, 1, 1);
            var end = DateUtility.MaxDate;
            var range = new DateRange(start, end);

            var id = new MDM.Contracts.NexusId { SystemName = "Test", Identifier = "A" };
            var contractDetails = new MDM.Contracts.CurveDetails();
            var contract = new MDM.Contracts.Curve
            {
                Identifiers = new MDM.Contracts.NexusIdList { id },
                Details = contractDetails,
                Nexus = new MDM.Contracts.SystemData { StartDate = start, EndDate = end }
            };

            // NB Don't assign validity here, want to prove SUT sets it
            var details = new Curve();

            var mapping = new CurveMapping();

            var mappingEngine = new Mock<IMappingEngine>();
            mappingEngine.Setup(x => x.Map<MDM.Contracts.NexusId, CurveMapping>(id)).Returns(mapping);
            mappingEngine.Setup(x => x.Map<MDM.Contracts.CurveDetails, Curve>(contractDetails)).Returns(details);

            var mapper = new CurveMapper(mappingEngine.Object);

            // Act
            var candidate = mapper.Map(contract);

            // Assert
            //Assert.AreEqual(1, candidate.Details.Count, "Detail count differs");
            Assert.AreEqual(1, candidate.Mappings.Count, "Mapping count differs");
            Check(range, details.Validity, "Validity differs");
        }

        public void Constructor_ValidDateRange_Succeeds()
        {
            DateTime effectiveDate = new DateTime ( 2000, 1, 1 );
            DateTime expirationDate = new DateTime ( 2000, 2, 1 );

            DateRange dateRange = new DateRange ( effectiveDate, expirationDate );
        }

 /**
  * @param validSince `validSince` is a <code>DateTime</code> object, it's the first time Pipl's
  *                   crawlers found this data on the page.
  * @param degree     degree
  * @param school     school
  * @param dateRange  `dateRange` is A <code>DateRange</code> object (Pipl.APIs.Data.Fields.DateRange),
  *                   that's the time the person was studying.
  */
 public Education(string degree = null, string school = null, DateRange dateRange = null, DateTime? validSince = null)
     : base(validSince)
 {
     this.Degree = degree;
     this.School = school;
     this.DateRange = dateRange;
 }

        public static IList<ITask> Collapse(this IEnumerable<ITask> taskCollection)
        {
            var taskList = taskCollection.ToList();

            if (taskCollection == null)
            {
                return null;
            }

            var output = new Collection<ITask>();

            // Grabbing all time split points and sorting them
            List<DateTime> timeEvents = taskList.SelectMany(task => new[] { task.DateRange.StartTime, task.DateRange.EndTime })
                                                     .Distinct()
                                                     .OrderBy(x => x)
                                                     .ToList();

            for (var i = 0; i < timeEvents.Count - 1; i++)
            {
                var newSpan = new DateRange(timeEvents[i], timeEvents[i + 1]);

                var overlappingTasks = taskList.Where(x => x.DateRange.Overlaps(newSpan));

                if (overlappingTasks.Any())
                {
                    var quantityPerHour = overlappingTasks.Sum(x => x.QuantityPerHour);
                    output.Add(Task.CreateUsingQuantityPerHour(newSpan, quantityPerHour));
                }
            }

            return output;
        }

    /// <summary>
    /// Run the code example.
    /// </summary>
    /// <param name="service">An initialized Dfa Reporting service object
    /// </param>
    public override void Run(DfareportingService service) {
      long profileId = long.Parse(_T("INSERT_USER_PROFILE_ID_HERE"));

      string reportName = _T("INSERT_REPORT_NAME_HERE");

      // Create a date range to report on.
      DateRange dateRange = new DateRange();
      dateRange.RelativeDateRange = "YESTERDAY";

      // Create a dimension to report on.
      SortedDimension dimension = new SortedDimension();
      dimension.Name = "dfa:campaign";

      // Create the criteria for the report.
      Report.CriteriaData criteria = new Report.CriteriaData();
      criteria.DateRange = dateRange;
      criteria.Dimensions = new List<SortedDimension>() { dimension };
      criteria.MetricNames = new List<string>() { "dfa:clicks" };

      // Create the report.
      Report report = new Report();
      report.Criteria = criteria;
      report.Name = reportName;
      report.Type = "STANDARD";

      // Insert the report.
      Report result = service.Reports.Insert(report, profileId).Execute();

      // Display the new report ID.
      Console.WriteLine("Standard report with ID {0} was created.", result.Id);
    }

 public void Constructor_SetsStartDateAndEndDateValues()
 {
     DateTime? startDate = DateTime.Today;
     DateTime? endDate = DateTime.Today.AddDays(1);
     var target = new DateRange(startDate, endDate);
     Assert.AreEqual(startDate, target.StartDate);
     Assert.AreEqual(endDate, target.EndDate);
 }

        public virtual RedirectToRouteResult DateRange(DateRange range)
        {
            var query = Session.Get<ActivityQuery>();
            query.DateFrom = DateRangeToDateTime(range);
            query.DateTo = null;

            return RedirectToAction(MVC.Activities.ActionNames.Index);
        }

        public int MostSolutionsBetween(DateRange range)
        {
            var result = this.quizzes.All()
                .Max(q => q.Solutions.Count(
                    s => range.From <= s.CreatedOn && s.CreatedOn <= range.To));

            return result;
        }