public void TestRoundRangeToInterval()
        {
            DateTime startDate = new DateTime(2008, 05, 1, 10, 2, 3, 4, DateTimeKind.Utc);
            DateTime startRounded1 = new DateTime(2008, 05, 1, 10, 2, 0, 0, DateTimeKind.Utc);
            DateTime startRounded15 = new DateTime(2008, 05, 1, 10, 0, 0, 0, DateTimeKind.Utc);
            DateTime endDate = new DateTime(2008, 05, 1, 11, 2, 3, 4, DateTimeKind.Utc);
            DateTime endRounded1 = new DateTime(2008, 05, 1, 11, 3, 0, 0, DateTimeKind.Utc);
            DateTime endRounded15 = new DateTime(2008, 05, 1, 11, 15, 0, 0, DateTimeKind.Utc);

            DateTimeRange range = new DateTimeRange(startDate, endDate);
            DateTimeRange rounded = DateUtil.RoundRangeToInterval(range, 1);
            Assert.AreEqual(rounded.Start, startRounded1);
            Assert.AreEqual(rounded.End, endRounded1);

            DateTimeRange twiceRounded = DateUtil.RoundRangeToInterval(rounded, 1);
            Assert.AreEqual(rounded.Start, twiceRounded.Start);
            Assert.AreEqual(rounded.End, twiceRounded.End);

            rounded = DateUtil.RoundRangeToInterval(range, 15);
            Assert.AreEqual(rounded.Start, startRounded15);
            Assert.AreEqual(rounded.End, endRounded15);

            twiceRounded = DateUtil.RoundRangeToInterval(rounded, 15);
            Assert.AreEqual(rounded.Start, twiceRounded.Start);
            Assert.AreEqual(rounded.End, twiceRounded.End);
        }

 public void NotEqualSamePrecisionHourTest()
 {
     var d1 = new DateTimeRange(new DateTime(2011, 4, 4, 10, 34, 10), DateTimeRange.PrecisionType.Hours);
     var d2 = new DateTimeRange(new DateTime(2011, 4, 4, 11, 20, 10), DateTimeRange.PrecisionType.Hours);
     Assert.AreNotEqual(d1, d2);
     Assert.AreNotEqual(d2, d1);
 }

        public bool TryGetCrossRange(DateTimeRange range, out DateTimeRange? crossRange)
        {
            crossRange = null;
            if (!IsIntersect(range)) return false;

            // Range полностью лежит в периоде
            if (range.Begin >= Begin && range.End <= End)
            {
                crossRange = range;
                return true;
            }

            // Период анализируемый период слева
            if (range.Begin < Begin && range.End <= End)
            {
                crossRange = new DateTimeRange(Begin, range.End);
                return true;
            }

            // Период нарушения пересекает период справа
            if (range.Begin >= Begin && range.End > End)
            {
                crossRange = new DateTimeRange(range.Begin, End);
                return true;
            }

            // Период полностью лежит в периоде нарушения
            crossRange = this;
            return true;
        }

        public void TestSortedIntervalTree()
        {
            DateTimeRange r0 = new DateTimeRange(baseDate, baseDate.AddHours(2));
            DateTimeRange r1 = new DateTimeRange(baseDate, baseDate.AddHours(4));
            DateTimeRange r2 = new DateTimeRange(baseDate, baseDate.AddHours(7));
            DateTimeRange r3 = new DateTimeRange(baseDate.AddHours(3), baseDate.AddHours(3));
            DateTimeRange r4 = new DateTimeRange(baseDate.AddHours(4), baseDate.AddHours(12));
            DateTimeRange r5 = new DateTimeRange(baseDate.AddHours(5), baseDate.AddHours(7));

            tree.Insert(r0, r0);
            tree.Insert(r1, r1);
            tree.Insert(r2, r2);
            tree.Insert(r3, r3);
            tree.Insert(r4, r4);
            tree.Insert(r5, r5);

            Assert.AreEqual(6, tree.NumNodes);
            Assert.AreEqual(5, tree.MaxDepth); // TODO

            DateTimeRange s0 = new DateTimeRange(baseDate.AddHours(1), baseDate.AddHours(1));
            List<DateTimeRange> result = tree.FindAll(s0);

            Assert.AreEqual(3, result.Count);
            Assert.AreEqual(r0, result[0]);
            Assert.AreEqual(r1, result[1]);
            Assert.AreEqual(r2, result[2]);
        }

        /// <summary>
        /// Returns the free busy times for the specified exchange users
        /// </summary>
        /// <param name="users">The user which free/busy blocks will be looked up for</param>
        /// <param name="window">The time period to look up FB info for</param>
        /// <returns></returns>
        public Dictionary<ExchangeUser, FreeBusy> LookupFreeBusyTimes(
            ExchangeUserDict users,
            DateTimeRange window )
        {
            /* Create an array of mailboxes to retrieve from exchange */
            Dictionary<ExchangeUser, FreeBusy> result = new Dictionary<ExchangeUser, FreeBusy>();

            try
            {
                using (BlockTimer bt = new BlockTimer("LookupFreeBusyTimes"))
                {
                    /* Perform the retrieval of free busy times through WebDav */
                    result = webDavQuery.LoadFreeBusy(exchangeServerUrl, users, window);
                }
            }
            catch (Exception ex)
            {
                throw new GCalExchangeException(
                    GCalExchangeErrorCode.ExchangeUnreachable,
                   "Error occured while retrieving free busy ranges",
                   ex);
            }

            return result;
        }

 public void EqualDifferentPrecisionHourMinuteTest()
 {
     var d1 = new DateTimeRange(new DateTime(2011, 4, 4, 10, 34, 10), DateTimeRange.PrecisionType.Minutes);
     var d2 = new DateTimeRange(new DateTime(2011, 4, 4, 10, 1, 4), DateTimeRange.PrecisionType.Hours);
     Assert.AreEqual(d1, d2);
     Assert.AreEqual(d2, d1);
 }

        public IList<Portrait> GetPortraits(int cameraId, DateTimeRange range)
        {
            var portraits = from f in System.IO.Directory.GetFiles(this._directoryPath, "*.jpg")
                            select new Portrait(f);

            return portraits.ToList();
        }

        /// <summary>
        /// Generates a response from a GCalRequest
        /// </summary>
        /// <returns></returns>
        public string GenerateResponse()
        {
            /* Create a string builder to hold the text for the response */
            StringBuilder result = new StringBuilder(4096);

            /* Create an exchange provider */
            ExchangeService gateway = new ExchangeService(
                ConfigCache.ExchangeServerUrl,
                ConfigCache.ExchangeUserLogin,
                ConfigCache.ExchangeUserPassword);

            /* Return the exchangers from the GCal Request that was passed in */
            DateTimeRange range = new DateTimeRange(request.UTCStartDate, request.UTCEndDate);
            ExchangeUserDict exchangeUsers = gateway.SearchByEmail(range, request.ExchangeUsers);

            /* Create the header of the request */
            result.AppendFormat("['{0}','{1}',", request.VersionNumber, request.MessageId);

            result.AppendFormat("['_ME_AddData','{0}/{1}','{2}'",
                                DateUtil.FormatDateForGoogle(request.StartDate),
                                DateUtil.FormatDateForGoogle(request.EndDate),
                                DateUtil.FormatDateTimeForGoogle(request.Since));

            /* Flag for inserting commas */
            bool firstUser = true;

            result.Append(",[");

            foreach (ExchangeUser user in exchangeUsers.Values)
            {
                /* Don't add a comma if this is the first user */
                if (!firstUser)
                {
                    result.Append(",");
                }

                /* Add the user's credentials */
                string email = ConfigCache.MapToExternalDomain(user.Email);
                result.AppendFormat("'{0}','{1}','{2}',[",
                                    user.DisplayName,
                                    email,
                                    (int)user.AccessLevel);

                GenerateResponseForTimeBlocks(user,
                                              result);

                result.Append("]");
                firstUser = false;
            }

            result.Append("]");
            result.Append("]");
            result.Append("]");

            log.Info("GCal Free/Busy response successfully generated.");
            log.DebugFormat("Response = {0}", result);

            return result.ToString();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Appointment"/> class.
        /// </summary>
        /// <param name="staff">The staff.</param>
        /// <param name="appointmentDateTimeRange">The appointment date time range.</param>
        protected internal Appointment( Staff staff, DateTimeRange appointmentDateTimeRange )
        {
            Check.IsNotNull ( staff, "Staff is required." );
            Check.IsNotNull ( appointmentDateTimeRange, "AppointmentDateTimeRange is required." );

            _staff = staff;
            _appointmentDateTimeRange = appointmentDateTimeRange;
        }

    public Task<IReadOnlyList<EntityIdWithVersion<Uri, string>>> GetTodos (DateTimeRange? range)
    {
      if (range != null)
        throw new NotSupportedException ("range not supported");

      return Task.FromResult<IReadOnlyList<EntityIdWithVersion<Uri, string>>> (
          _entites.Select (e => EntityIdWithVersion.Create (e.Key, e.Value.Item1)).ToList());
    }

        /// <summary>
        /// Creates the appointment.
        /// </summary>
        /// <param name="staff">
        /// The staff.
        /// </param>
        /// <param name="appointmentDateTimeRange">
        /// The appointment date time range.
        /// </param>
        /// <returns>
        /// An Appointment.
        /// </returns>
        public Appointment CreateAppointment( Staff staff, DateTimeRange appointmentDateTimeRange )
        {
            var appointment = new Appointment ( staff, appointmentDateTimeRange );

            _appointmentRepository.MakePersistent ( appointment );

            return appointment;
        }

        public void TestDateTimeRange()
        {
            DateTimeRange range = new DateTimeRange(startDate, endDate);
            DateTimeRange compareRange = new DateTimeRange(startDate, endDate);

            Assert.AreEqual(startDate, range.Start);
            Assert.AreEqual(endDate, range.End);
            Assert.AreEqual(range, compareRange);
            Assert.AreEqual(range.GetHashCode(), compareRange.GetHashCode());
        }

        public void LoadVideo()
        {
            var selectedCamera = this._screen.SelectedCamera;
            if (selectedCamera == null)
            {
                return;
            }

            var range = this._screen.TimeRange;
            var type = this._screen.SearchScope;
            var frameQuery = _portraitRepository.GetFrames(selectedCamera.Id, range).ToArray();
            var portraitQuery = _portraitRepository.GetPortraits(selectedCamera.Id, range).ToArray();
            Core.Video v;
            this._screen.ClearAll();

            for (int i = currentPage * PageSize; i < currentPage * PageSize + PageSize; i++)
            {
                if (i >= TotalCount)
                {
                    break;
                }
                v = TotalVideos[i];
                var queryTime = new DateTimeRange(v.CapturedAt, v.CapturedAt);
                v.HasMotionDetected = frameQuery.FirstOrDefault(f => f.CapturedAt.RoundToMinute() == v.CapturedAt.RoundToMinute()) != null;
                v.HasFaceCaptured = portraitQuery.FirstOrDefault(p => p.CapturedAt.RoundToMinute() == v.CapturedAt.RoundToMinute()) != null;
                if ((type & SearchScope.FaceCapturedVideo)
                      == SearchScope.FaceCapturedVideo)
                {
                    if (v.HasFaceCaptured)
                    {
                        _screen.AddVideo(v);
                    }
                }

                if ((type & SearchScope.MotionWithoutFaceVideo)
                     == SearchScope.MotionWithoutFaceVideo)
                {
                    if (v.HasMotionDetected && !v.HasFaceCaptured)
                    {
                        _screen.AddVideo(v);
                    }
                }

                if ((type & SearchScope.MotionLessVideo)
                      == SearchScope.MotionLessVideo)
                {
                    if (!v.HasFaceCaptured && !v.HasMotionDetected)
                    {
                        _screen.AddVideo(v);
                    }
                }

            }
        }

        public void DateTimeRangeTest_Ctor()
        {
            DateTimeRange range = new DateTimeRange();
            Assert.AreEqual(range.StartTime, DateTime.MinValue);
            Assert.AreEqual(range.EndTime, DateTime.MaxValue);

            DateTime now = new DateTime(2015, 8, 7, 11, 15, 22);
            range = new DateTimeRange(now.Date.AddDays(-1), now.Date.AddDays(2));
            Assert.AreEqual(range.StartTime.Day, 6);
            Assert.AreEqual(range.EndTime.Day, 9);
        }

        /// <summary>
        /// Creates the visit.
        /// </summary>
        /// <param name="staff">The staff.</param>
        /// <param name="appointmentDateTimeRange">The appointment date time range.</param>
        /// <param name="clinicalCase">The clinical case.</param>
        /// <param name="visitTemplate">The visit template.</param>
        /// <param name="serviceLocation">The service location.</param>
        /// <returns>
        /// A Visit.
        /// </returns>
        public Visit CreateVisit(Staff staff, 
            DateTimeRange appointmentDateTimeRange,
            ClinicalCase clinicalCase,
            VisitTemplate visitTemplate,
            Location serviceLocation )
        {
            var visitStatus = _visitStatusRepository.GetByWellKnownName ( WellKnownNames.VisitModule.VisitStatus.Scheduled );
            var visit = new Visit (staff, appointmentDateTimeRange, clinicalCase, visitStatus, serviceLocation, visitTemplate.Name, visitTemplate.CptCode );

            _visitRepository.MakePersistent ( visit );
            return visit;
        }

        public void TestOverlapsAndContains()
        {
            DateTime date7AM = new DateTime(2007, 1, 1, 7, 0, 0);
            DateTime date8AM = new DateTime(2007, 1, 1, 8, 0, 0);
            DateTime date9AM = new DateTime(2007, 1, 1, 9, 0, 0);
            DateTime date10AM = new DateTime(2007, 1, 1, 10, 0, 0);

            DateTimeRange range7AM8AM = new DateTimeRange(date7AM, date8AM);
            DateTimeRange range9AM10AM = new DateTimeRange(date9AM, date10AM);

            // The first test case is
            // 7-8  [.....]
            // 9-10           [.....]
            // Don't intersect and don't contain
            Assert.IsFalse(range7AM8AM.Overlaps(range9AM10AM));
            Assert.IsFalse(range9AM10AM.Overlaps(range7AM8AM));
            Assert.IsFalse(range7AM8AM.Contains(range9AM10AM));
            Assert.IsFalse(range9AM10AM.Contains(range7AM8AM));

            DateTimeRange range7AM10AM = new DateTimeRange(date7AM, date10AM);
            DateTimeRange range8AM9AM = new DateTimeRange(date8AM, date9AM);

            // The second test case is
            // 7-10 [...............]
            // 8-9       [.....]
            // Intersect, the bigger contains the smaller
            Assert.IsTrue(range7AM10AM.Overlaps(range8AM9AM));
            Assert.IsTrue(range8AM9AM.Overlaps(range7AM10AM));
            Assert.IsTrue(range7AM10AM.Contains(range8AM9AM));
            Assert.IsFalse(range8AM9AM.Contains(range7AM10AM));

            // The third test case is
            // 8-9       [.....]
            // 9-10           [.....]
            // Intersect (touch), don't contain each other
            Assert.IsTrue(range8AM9AM.Overlaps(range9AM10AM));
            Assert.IsTrue(range9AM10AM.Overlaps(range8AM9AM));
            Assert.IsFalse(range8AM9AM.Contains(range9AM10AM));
            Assert.IsFalse(range9AM10AM.Contains(range8AM9AM));

            DateTimeRange range7AM9AM = new DateTimeRange(date7AM, date9AM);
            DateTimeRange range8AM10AM = new DateTimeRange(date8AM, date10AM);

            // The forth test case is
            // 7-9  [..........]
            // 9-10      [..........]
            // Intersect, don't contain each other
            Assert.IsTrue(range7AM9AM.Overlaps(range8AM10AM));
            Assert.IsTrue(range8AM10AM.Overlaps(range7AM9AM));
            Assert.IsFalse(range7AM9AM.Contains(range8AM10AM));
            Assert.IsFalse(range8AM10AM.Contains(range7AM9AM));
        }

        public static ExchangeUserDict QueryFreeBusy(string email)
        {
            ExchangeService gw = new ExchangeService(
                ConfigCache.ExchangeServerUrl,
                ConfigCache.ExchangeUserLogin,
                ConfigCache.ExchangeUserPassword );

            DateTimeRange range = new DateTimeRange(
                DateUtil.NowUtc.AddDays(-7),
                DateUtil.NowUtc.AddDays(+7));

            return gw.SearchByEmail( range, email );
        }

 public void TestConvertEventsToFreeBusy()
 {
     ExchangeUser user = new ExchangeUser();
     EventEntry googleAppsEvent = new EventEntry("title", "description", "location");
     DateTimeRange coveredRange = new DateTimeRange(DateTime.MaxValue, DateTime.MinValue);
     List<DateTimeRange> busyTimes = new List<DateTimeRange>();
     List<DateTimeRange> tentativeTimes = new List<DateTimeRange>();
     DateTime startDate = new DateTime(2007, 07, 1, 10, 0, 0, DateTimeKind.Utc);
     DateTime endDate = new DateTime(2007, 07, 1, 11, 0, 0, DateTimeKind.Utc);
     When when = new When(startDate, endDate);
     Uri uri = new Uri("https://www.google.com/calendar/feeds/[email protected]/private/full");
     EventFeed googleAppsFeed = new EventFeed(uri, null);
     AtomEntryCollection entries = new AtomEntryCollection(googleAppsFeed);
 }

        public void FreeBusyUrls()
        {
            Assert.AreEqual(FreeBusyTestUrl, FreeBusyUrl.GenerateUrl(ExchangeServer, Organization, OrgUnit));
            Assert.AreEqual(FreeBusyFromDNUrl, FreeBusyUrl.GenerateUrlFromDN(ExchangeServer, LegacyDN));
            Assert.AreEqual(AdminGroupUrl, FreeBusyUrl.GenerateAdminGroupUrl(ExchangeServer, AdminGroup));

            ExchangeUserDict users = new ExchangeUserDict();
            users.Add(User1Email, createFauxUser("User1", User1Email));

            DateTimeRange range = new DateTimeRange(start, end);
            Assert.AreEqual(SingleUserFreeBusyUrl, FreeBusyUrl.GenerateFreeBusyLookupUrl(ExchangeServer, users, range, 15));

            users.Add(User2Email, createFauxUser("User2", User2Email));
            Assert.AreEqual(MultiUserFreeBusyUrl, FreeBusyUrl.GenerateFreeBusyLookupUrl(ExchangeServer, users, range, 15));
        }

        public IEnumerable<DtoLicensePlateInfo> GetLicensePlatesBetween(int cameraId, DateTimeRange dateTimeRange)
        {
            return _db4oContainer.Query<DtoLicensePlateInfo>(l =>
                                                                 {

                                                                     var match = l.CaptureTime >= dateTimeRange.From &&
                                                                                 l.CaptureTime <= dateTimeRange.To;

                                                                     if (cameraId != -1)
                                                                     {
                                                                         match = match && l.CapturedFrom == cameraId;
                                                                     }
                                                                                 ;
                                                                     return match;
                                                                 });
        }