private static void InitCustomers() { DateTimeOffset dto = new DateTimeOffset(2015, 1, 1, 1, 2, 3, 4, TimeSpan.Zero); _customers = Enumerable.Range(1, 5).Select(e => new DCustomer { Id = e, DateTime = dto.AddYears(e).DateTime, Offset = e % 2 == 0 ? dto.AddMonths(e) : dto.AddDays(e).AddMilliseconds(10), Date = e % 2 == 0 ? dto.AddDays(e).Date : dto.AddDays(-e).Date, TimeOfDay = e % 3 == 0 ? dto.AddHours(e).TimeOfDay : dto.AddHours(-e).AddMilliseconds(10).TimeOfDay, NullableDateTime = e % 2 == 0 ? (DateTime?)null : dto.AddYears(e).DateTime, NullableOffset = e % 3 == 0 ? (DateTimeOffset?)null : dto.AddMonths(e), NullableDate = e % 2 == 0 ? (Date?)null : dto.AddDays(e).Date, NullableTimeOfDay = e % 3 == 0 ? (TimeOfDay?)null : dto.AddHours(e).TimeOfDay, DateTimes = new [] { dto.AddYears(e).DateTime, dto.AddMonths(e).DateTime }, Offsets = new [] { dto.AddMonths(e), dto.AddDays(e) }, Dates = new [] { (Date)dto.AddYears(e).Date, (Date)dto.AddMonths(e).Date }, TimeOfDays = new [] { (TimeOfDay)dto.AddHours(e).TimeOfDay, (TimeOfDay)dto.AddMinutes(e).TimeOfDay }, NullableDateTimes = new [] { dto.AddYears(e).DateTime, (DateTime?)null, dto.AddMonths(e).DateTime }, NullableOffsets = new [] { dto.AddMonths(e), (DateTimeOffset?)null, dto.AddDays(e) }, NullableDates = new [] { (Date)dto.AddYears(e).Date, (Date?)null, (Date)dto.AddMonths(e).Date }, NullableTimeOfDays = new [] { (TimeOfDay)dto.AddHours(e).TimeOfDay, (TimeOfDay?)null, (TimeOfDay)dto.AddMinutes(e).TimeOfDay }, }).ToList(); }
public void Between() { var date = new DateTimeOffset(2015, 8, 7, 13, 26, 30, TimeSpan.Zero); Assert.IsTrue(date.Between(date.AddMonths(-3), date.AddMonths(3))); Assert.IsTrue(date.AddHours(36).Between(date.AddMonths(-3), date.AddMonths(3))); Assert.IsFalse(date.AddMonths(6).Between(date.AddMonths(-3), date.AddMonths(3))); Assert.IsFalse(date.AddHours(-2).Between(date, date.AddMonths(3))); Assert.IsTrue(date.Between(date.AddMonths(-3), date.AddMonths(3), false)); Assert.IsTrue(date.AddHours(36).Between(date.AddMonths(-3), date.AddMonths(3), false)); Assert.IsFalse(date.AddMonths(6).Between(date.AddMonths(-3), date.AddMonths(3), false)); Assert.IsTrue(date.AddHours(-2).Between(date, date.AddMonths(3), false)); Assert.IsFalse(date.AddHours(-24).Between(date, date.AddMonths(3), false)); }
internal long GetNextOccurrence() { DateTimeOffset now = _ClockSource.Now; DateTimeOffset next; switch (this.Periodicity) { case PeriodicityType.Hourly: next = new DateTimeOffset(now.Year, now.Month, now.Day, now.Hour, this.MinuteOffset, 0, now.Offset); if (next <= now) { next = next.AddHours(1.0); } break; case PeriodicityType.Daily: next = new DateTimeOffset(now.Year, now.Month, now.Day, this.HourOffset, this.MinuteOffset, 0, now.Offset); if (next <= now) { next = next.AddDays(1.0); } break; default: goto case PeriodicityType.Hourly; } return next.ToUniversalTime().Ticks; }
public void Dividing() { var now = new DateTimeOffset(2013, 8, 13, 13, 0, 0, TimeSpan.FromHours(12)); var availableTime = new TimeRange(now, now.AddHours(1)); var freeSlots = availableTime .Divide(TimeSpan.FromMinutes(15)) .ToArray(); Assert.AreEqual(4, freeSlots.Length); Assert.IsTrue(freeSlots.All(s => s.Duration == TimeSpan.FromMinutes(15))); }
public void CanAddHoursAcrossDstTransition() { var tz = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"); var dto = new DateTimeOffset(2015, 3, 8, 1, 0, 0, TimeSpan.FromHours(-8)); var result = dto.AddHours(1, tz); var expected = new DateTimeOffset(2015, 3, 8, 3, 0, 0, TimeSpan.FromHours(-7)); Assert.Equal(expected, result); Assert.Equal(expected.Offset, result.Offset); }
/// <summary> /// Returns a value indicating whether the provided DaysOfWeek value is applicable today. /// </summary> public static bool IsToday(DaysOfWeek days, DateTimeOffset currentTime) { // special handling for Night Owl so that its schedule is visible after midnight // i.e., if it's 2AM on Sunday, we still consider "today" to be Saturday. var time = (days == DaysOfWeek.NightOwl) ? currentTime.AddHours(-4) : currentTime; return (ToDaysOfWeek(time.DayOfWeek) & days) != DaysOfWeek.None; }
static void Main(string[] args) { //var offset = DateTimeOffset.Now; //Debug.WriteLine(offset); //Debug.WriteLine(DateTimeOffset.UtcNow); //String s = "10/1/2014 6:17 PM"; //DateTime dt = DateTime.ParseExact(s, "MM/dd/yyyy h:mm tt", CultureInfo.InvariantCulture); //DateTimeOffset dto = new DateTimeOffset(dt); DateTimeOffset dto1 = new DateTimeOffset(); dto1 = DateTimeOffset.Now; dto1 = dto1.AddHours(2); dto1 = dto1.AddMinutes(30); Debug.WriteLine(DateTimeOffset.Now); Debug.WriteLine(dto1); TimeSpan diff = dto1.Subtract(DateTimeOffset.Now); Debug.WriteLine(diff); Debug.WriteLine(diff.TotalHours); Debug.WriteLine(diff.TotalSeconds); var diffsec = (DateTimeOffset.Now - dto1).TotalSeconds; Debug.WriteLine(diffsec); //dtoff.Value.ToLocalTime().ToString("dddd, MMM dd yyyy HH:mm", new CultureInfo("en-US")); //Debug.WriteLine(dto1); //Debug.WriteLine(dto2); //Debug.WriteLine(DateTimeOffset.Now); //Debug.WriteLine(dto1 - DateTimeOffset.Now); //Debug.WriteLine(DateTimeOffset.Now - dto1); //Debug.WriteLine(dto1.CompareTo(DateTimeOffset.Now)); //Debug.WriteLine(DateTimeOffset.Now.CompareTo(dto1)); //Debug.WriteLine(" "); //Debug.WriteLine(dto1.Hour); double temp = -26; double res = 0; for (int i = 0; i < 40; i++) { temp++; res = 0.5 - (temp * 0.1); Debug.WriteLine("Temp: " + temp + " Result: " + res); } //Debug.WriteLine(s); //Debug.WriteLine(dt.ToString()); //Debug.WriteLine(dt.ToUniversalTime().ToString()); //Debug.WriteLine(dto.ToString()); }
public void TestCronTriggerTimeZoneWillFire() { string tzId = "GMT Standard Time"; TimeZoneInfo tz = TZConvert.GetTimeZoneInfo(tzId); TimeSpan tzOffset = tz.BaseUtcOffset; DateTimeOffset startDate = new DateTimeOffset(new DateTime(2021, 1, 1, 0, 0, 0, DateTimeKind.Utc), tzOffset); DateTimeOffset expectedFire = startDate.AddHours(5).AddMinutes(50); CronTriggerImpl trigger = new CronTriggerImpl(); trigger.Name = "Quartz-Custom"; trigger.Group = SchedulerConstants.DefaultGroup; trigger.TimeZone = tz; trigger.CronExpressionString = "0 50 5,11,17,23 ? * *"; trigger.StartTimeUtc = startDate; Assert.AreEqual(expectedFire, trigger.GetFireTimeAfter(startDate), $"Expected to fire at {expectedFire}"); Assert.IsTrue(trigger.WillFireOn(expectedFire), $"Expected to fire at {expectedFire}"); Assert.IsTrue(trigger.WillFireOn(expectedFire.AddHours(6)), $"Expected to fire at {expectedFire}"); Assert.IsTrue(trigger.WillFireOn(expectedFire.AddHours(12)), $"Expected to fire at {expectedFire}"); Assert.IsTrue(trigger.WillFireOn(expectedFire.AddHours(18)), $"Expected to fire at {expectedFire}"); Assert.IsTrue(trigger.WillFireOn(expectedFire.AddHours(24)), $"Expected to fire at {expectedFire}"); }
public void SetsTheStopTimeToParameterStopTimeIfParameterHasStopTime(DateTimeOffset now) { var start = now.AddHours(-4); var stop = start.AddHours(2); var parameter = DurationParameter.WithStartAndDuration(start, stop - now); var observer = TestScheduler.CreateObserver <DateTimeOffset>(); ViewModel.StartTime.Subscribe(observer); ViewModel.Initialize(new EditDurationParameters(parameter)); TestScheduler.Start(); observer.LastEmittedValue().Should().BeSameDateAs(start); }
private void CrawlAllPlays(int minimumHoursPassed) { if (_lastTimeAllPlays.AddHours(minimumHoursPassed) > DateTimeOffset.Now) { return; } var plays = _geekConnector.GetPlays("kuhlschrank"); Log($"{plays.Count()} plays found."); _repository.StorePlays(plays); Log($"{plays.Count()} plays updated."); _lastTimeAllPlays = DateTimeOffset.Now; }
public void SetsTheStartTimeToTheValueReturnedByTheSelectDateTimeDialogViewModelWhenEditingARunningTimeEntry(DateTimeOffset now) { var parameterToReturn = DurationParameter.WithStartAndDuration(now.AddHours(-3), null); NavigationService .Navigate <DurationParameter, DurationParameter>(typeof(EditDurationViewModel), Arg.Any <DurationParameter>()) .Returns(parameterToReturn); ConfigureEditedTimeEntry(now); ViewModel.Prepare(Id); ViewModel.EditDurationCommand.ExecuteAsync().Wait(); ViewModel.StartTime.Should().Be(parameterToReturn.Start); }
public override DateTimeOffset?CalculateNextFireTime() { if (!prevFireTime.HasValue) { return(null); } if (maxRepeats != InfiniteRepeats && maxRepeats == context.TimesRun) { return(null); } if (finalFireTime.HasValue && finalFireTime < Time.Now()) { return(null); } DateTimeOffset result = prevFireTime.Value; switch (Period) { case TimeInterval.Seconds: result = result.AddSeconds(interval); break; case TimeInterval.Minutes: result = result.AddMinutes(interval); break; case TimeInterval.Hours: result = result.AddHours(interval); break; case TimeInterval.Days: result = result.AddDays(interval); break; case TimeInterval.Weeks: result = result.AddDays(7 * interval); break; case TimeInterval.Months: result = result.AddMonths(interval); break; case TimeInterval.Years: result = result.AddYears(interval); break; } return(result); }
public void WhenChangedWhileUpdatingTheRunningTimeEntryTriggersTheUpdateOfTheStartTime(DateTimeOffset now) { var start = now.AddHours(-2); var parameter = DurationParameter.WithStartAndStop(start, null); TimeService.CurrentDateTime.Returns(now); ViewModel.Prepare(parameter); ViewModel.Duration = TimeSpan.FromHours(4); var expectedStart = start.AddHours(-2); ViewModel.StartTime.Should().BeSameDateAs(expectedStart); }
//画像が削除されて意味がなくなったツイートを消す //URL転載したやつの転載元ツイートが消された場合 public int RemoveOrphanTweet() { const int BulkUnit = 100; const int RangeSeconds = 300; const string head = @"DELETE FROM tweet WHERE tweet_id IN"; string BulkDeleteCmd = BulkCmdStrIn(BulkUnit, head); TransformBlock <long, DataTable> GetTweetBlock = new TransformBlock <long, DataTable>(async(long id) => { using (MySqlCommand Cmd = new MySqlCommand(@"SELECT tweet_id FROM tweet WHERE retweet_id IS NULL AND NOT EXISTS (SELECT * FROM tweet_media WHERE tweet_media.tweet_id = tweet.tweet_id) AND tweet_id BETWEEN @begin AND @end ORDER BY tweet_id DESC;")) { Cmd.Parameters.AddWithValue("@begin", id); Cmd.Parameters.AddWithValue("@end", id + SnowFlake.msinSnowFlake * RangeSeconds * 1000 - 1); return(await SelectTable(Cmd, IsolationLevel.RepeatableRead)); } }, new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }); DateTimeOffset date = DateTimeOffset.UtcNow.AddHours(-1); for (int i = 0; i < 20; i++) { GetTweetBlock.Post(SnowFlake.SecondinSnowFlake(date, false)); date = date.AddHours(-1); } while (true) { DataTable Table = GetTweetBlock.Receive(); if (Table.Rows.Count > 0) { using (MySqlCommand delcmd = new MySqlCommand(BulkCmdStrIn(Table.Rows.Count, head))) { for (int n = 0; n < Table.Rows.Count; n++) { delcmd.Parameters.AddWithValue("@" + n.ToString(), Table.Rows[n].Field <long>(0)); } Console.WriteLine("{0} {1} Tweets removed", date, ExecuteNonQuery(delcmd)); } } GetTweetBlock.Post(SnowFlake.SecondinSnowFlake(date, false)); date = date.AddSeconds(-RangeSeconds); } }
public static DateTimeOffset RoundUpToClosestQuarter(this DateTimeOffset time) { if (time.Minute >= 45) { var nextHour = time.AddHours(1); return(new DateTimeOffset(nextHour.Year, nextHour.Month, nextHour.Day, nextHour.Hour, 0, 0, nextHour.Offset)); } else { var offset = 15 - time.Minute % 15; var minute = time.Minute + offset; return(new DateTimeOffset(time.Year, time.Month, time.Day, time.Hour, minute, 0, time.Offset)); } }
public void ShouldBeFalseWhenRemoteConfigHasBeenFetchedLessThan12HoursAndHalfAgo() { var now = new DateTimeOffset(2019, 1, 1, 12, 0, 0, TimeSpan.Zero); TimeService.CurrentDateTime.Returns(now); var thirteenHoursAgo = now.AddHours(-11); KeyValueStorage.GetDateTimeOffset(LastFetchAtKey).Returns(thirteenHoursAgo); UpdateRemoteConfigCacheService = new UpdateRemoteConfigCacheService(TimeService, KeyValueStorage, FetchRemoteConfigService); var needsToUpdateStoredRemoteConfigData = UpdateRemoteConfigCacheService.NeedsToUpdateStoredRemoteConfigData(); Assert.IsFalse(needsToUpdateStoredRemoteConfigData); }
public FormMoonRiver() { InitializeComponent(); DateTimeOffset now = DateTimeOffset.Now; DateTimeOffset thisHour = new DateTimeOffset(now.Year, now.Month, now.Day, now.Hour, 0, 0, now.Offset); intradaySince = thisHour.AddHours(-24); intradayUntil = thisHour.AddHours(24); interdaySince = new DateTimeOffset(now.Year, now.Month, now.Day, 0, 0, 0, TimeSpan.Zero).AddMonths(-1); interdayUntil = new DateTimeOffset(now.Year, now.Month, now.Day, 0, 0, 0, TimeSpan.Zero).AddMonths(1); InitiateGraphControl(geoIntraDay, intradaySince, intradayUntil); InitiateGraphControl(geoInterday, interdaySince, interdayUntil); addIntraDayCurves(); markPlanetEvent(); initializeEventsTab(); }
public void GetJobsToRun_ReturnsJobs() { var dateTimeOffset = new DateTimeOffset(DateTime.Today); var fromDateTimeOffset = dateTimeOffset.AddHours(-2); var toDateTimeOffset = dateTimeOffset.AddHours(4).AddMilliseconds(-1); var jobsContext = new JobsContext(); foreach (var jobItem in new[] { Midnight, EverydayAt0_OClock, EverydayAt4_OClock }) { jobsContext.JobItems.Add(jobItem); } var jobStorageItems = jobsContext.GetJobsToRun(fromDateTimeOffset, toDateTimeOffset); Assert.Equal(3, jobsContext.JobItems.Count); Assert.Equal(2, jobStorageItems.Length); }
protected void ConfigureEditedTimeEntry(DateTimeOffset now, bool isRunning = false) { var te = TimeEntry.Builder.Create(Id) .SetDescription("Something") .SetStart(now.AddHours(-2)) .SetAt(now.AddHours(-2)) .SetWorkspaceId(11) .SetUserId(12) .SetProjectId(13) .SetTaskId(14); if (!isRunning) { te = te.SetDuration((long)Duration.TotalSeconds); } TheTimeEntry = te.Build(); var observable = Observable.Return(TheTimeEntry); DataSource.TimeEntries.GetById(Arg.Is(Id)).Returns(observable); TimeService.CurrentDateTime.Returns(now); }
public async Task ReturnsSuggestionsFromEventsOneHourInThePastAndOneHourInTheFuture() { var now = new DateTimeOffset(2020, 1, 2, 3, 4, 5, TimeSpan.Zero); TimeService.CurrentDateTime.Returns(now); var tenMinutes = TimeSpan.FromMinutes(10); var events = Enumerable.Range(1, 5) .Select(id => new CalendarItem( id.ToString(), CalendarItemSource.Calendar, now - tenMinutes * id, tenMinutes, id.ToString(), CalendarIconKind.None)); CalendarService .GetEventsInRange(Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>()) .Returns(Observable.Return(events)); var userCalendar = new UserCalendar( "", "", "", true); InteractorFactory.GetUserCalendars().Execute() .Returns(Observable.Return(new List <UserCalendar> { userCalendar })); var suggestions = await Provider.GetSuggestions().ToList(); await CalendarService.Received().GetEventsInRange(now.AddHours(-1), now.AddHours(1)); suggestions.Should().HaveCount(1) .And.OnlyContain(suggestion => events.Any(@event => @event.Description == suggestion.Description)); }
public static void RSACertificateNoPaddingMode() { using (RSA rsa = RSA.Create()) { var request = new CertificateRequest( new X500DistinguishedName("CN=Test"), rsa, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1); request.CertificateExtensions.Add( new X509BasicConstraintsExtension(true, false, 0, true)); DateTimeOffset now = DateTimeOffset.UtcNow; using (X509Certificate2 cert = request.CreateSelfSigned(now, now.AddDays(1))) { request = new CertificateRequest( new X500DistinguishedName("CN=Leaf"), cert.PublicKey, HashAlgorithmName.SHA256); byte[] serialNumber = { 1, 1, 2, 3, 5, 8, 13 }; Assert.Throws <InvalidOperationException>( () => request.Create(cert, now, now.AddHours(3), serialNumber)); X509SignatureGenerator generator = X509SignatureGenerator.CreateForRSA(rsa, RSASignaturePadding.Pkcs1); // Passes with the generator using (request.Create(cert.SubjectName, generator, now, now.AddHours(3), serialNumber)) { } } } }
public void From_FromFixedDateTime_Tests(int value) { var originalPointInTime = new DateTimeOffset(1976, 12, 31, 17, 0, 0, 0, TimeSpan.Zero); Assert.AreEqual(value.Years().From(originalPointInTime), originalPointInTime.AddYears(value)); Assert.AreEqual(value.Months().From(originalPointInTime), originalPointInTime.AddMonths(value)); Assert.AreEqual(value.Weeks().From(originalPointInTime), originalPointInTime.AddDays(value*DaysPerWeek)); Assert.AreEqual(value.Days().From(originalPointInTime), originalPointInTime.AddDays(value)); Assert.AreEqual(value.Hours().From(originalPointInTime), originalPointInTime.AddHours(value)); Assert.AreEqual(value.Minutes().From(originalPointInTime), originalPointInTime.AddMinutes(value)); Assert.AreEqual(value.Seconds().From(originalPointInTime), originalPointInTime.AddSeconds(value)); Assert.AreEqual(value.Milliseconds().From(originalPointInTime), originalPointInTime.AddMilliseconds(value)); Assert.AreEqual(value.Ticks().From(originalPointInTime), originalPointInTime.AddTicks(value)); }
public TheIndexOfWithIdMethod() { mockCollection = new GroupedOrderedCollection <MockItem>(d => d.Id, d => d.Start.TimeOfDay, d => d.Start.Date, isDescending: true); List <MockItem> list = new List <MockItem> { new MockItem { Id = 0, Start = referenceDate.AddHours(3) }, new MockItem { Id = 1, Start = referenceDate.AddHours(1) }, new MockItem { Id = 2, Start = referenceDate.AddHours(-10) }, new MockItem { Id = 3, Start = referenceDate.AddDays(5) }, new MockItem { Id = 4, Start = referenceDate.AddDays(5).AddHours(2) } }; mockCollection.ReplaceWith(list); }
public async Task <List <OutstandingJobResult> > GetOutstandingOrTimedOutJobs(long?dcJobId, DateTimeOffset startTime, CancellationToken cancellationToken) { var latestValidStartTime = startTime.AddHours(-2).AddMinutes(-30); return(await Jobs.Where(x => x.DcJobId != dcJobId && x.JobType == JobType.EarningsJob && x.StartTime > latestValidStartTime). Select(x => new OutstandingJobResult() { DcJobId = x.DcJobId, DcJobSucceeded = x.DcJobSucceeded, JobStatus = x.Status, EndTime = x.EndTime }). ToListAsync(cancellationToken)); }
public void Ago_FromFixedDateTime_Tests(int agoValue) { var originalPointInTime = new DateTimeOffset(1976, 12, 31, 17, 0, 0, 0, TimeSpan.Zero); Assert.AreEqual(agoValue.Years().Before(originalPointInTime), originalPointInTime.AddYears(-agoValue)); Assert.AreEqual(agoValue.Months().Before(originalPointInTime), originalPointInTime.AddMonths(-agoValue)); Assert.AreEqual(agoValue.Weeks().Before(originalPointInTime), originalPointInTime.AddDays(-agoValue * DAYS_PER_WEEK)); Assert.AreEqual(agoValue.Days().Before(originalPointInTime), originalPointInTime.AddDays(-agoValue)); Assert.AreEqual(agoValue.Hours().Before(originalPointInTime), originalPointInTime.AddHours(-agoValue)); Assert.AreEqual(agoValue.Minutes().Before(originalPointInTime), originalPointInTime.AddMinutes(-agoValue)); Assert.AreEqual(agoValue.Seconds().Before(originalPointInTime), originalPointInTime.AddSeconds(-agoValue)); Assert.AreEqual(agoValue.Milliseconds().Before(originalPointInTime), originalPointInTime.AddMilliseconds(-agoValue)); Assert.AreEqual(agoValue.Ticks().Before(originalPointInTime), originalPointInTime.AddTicks(-agoValue)); }
private static async Task <string> GetStringCachedAsync(Uri targetUri, string cacheFileName) { string json = null; var localFolder = ApplicationData.Current.LocalFolder; var file = await localFolder.TryGetItemAsync(cacheFileName) as StorageFile; if (file != null) { var modifiedTime = (await file.GetBasicPropertiesAsync()).DateModified; var dateTimeOffsetNowJst = DateTimeOffset.Now.ToOffset(TimeSpan.FromHours(9)); var dateTimeOffsetTodayJst = new DateTimeOffset(dateTimeOffsetNowJst.Year, dateTimeOffsetNowJst.Month, dateTimeOffsetNowJst.Day, 0, 0, 0, TimeSpan.FromHours(9)); var borderTime = (dateTimeOffsetNowJst.TimeOfDay < TimeSpan.FromHours(3)) ? dateTimeOffsetTodayJst.AddHours(-21) // Yesterday 03:00:00 in JST : dateTimeOffsetTodayJst.AddHours(3); // Today 03:00:00 in JST if (borderTime < modifiedTime) { json = await FileIO.ReadTextAsync(file); } } if (String.IsNullOrEmpty(json)) { json = await GetStringAsync(targetUri); file = await localFolder.CreateFileAsync(cacheFileName, CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(file, json); } return(json); }
public void ConvertsInputTimesFromZonesToLocalTimeForUseInUI(int offset) { var zoneOffset = TimeSpan.FromHours(offset); var startTime = new DateTimeOffset(2018, 1, 1, 13, 15, 22, zoneOffset); var stopTime = startTime.AddHours(1); var localStartTime = startTime.ToLocalTime(); var localStopTime = stopTime.ToLocalTime(); var parameter = CreateParameter(startTime, stopTime); ViewModel.Prepare(parameter); ViewModel.StartTime.Should().Be(localStartTime); ViewModel.StopTime.Should().Be(localStopTime); }
public void From_FromFixedDateTime_Tests(int value) { var originalPointInTime = new DateTimeOffset(1976, 12, 31, 17, 0, 0, 0, TimeSpan.Zero); Assert.AreEqual(value.Years().From(originalPointInTime), originalPointInTime.AddYears(value)); Assert.AreEqual(value.Months().From(originalPointInTime), originalPointInTime.AddMonths(value)); Assert.AreEqual(value.Weeks().From(originalPointInTime), originalPointInTime.AddDays(value * DaysPerWeek)); Assert.AreEqual(value.Days().From(originalPointInTime), originalPointInTime.AddDays(value)); Assert.AreEqual(value.Hours().From(originalPointInTime), originalPointInTime.AddHours(value)); Assert.AreEqual(value.Minutes().From(originalPointInTime), originalPointInTime.AddMinutes(value)); Assert.AreEqual(value.Seconds().From(originalPointInTime), originalPointInTime.AddSeconds(value)); Assert.AreEqual(value.Milliseconds().From(originalPointInTime), originalPointInTime.AddMilliseconds(value)); Assert.AreEqual(value.Ticks().From(originalPointInTime), originalPointInTime.AddTicks(value)); }
public void SetsTheStartTimeToCurrentTimeIfParameterDoesNotHaveStartTime(DateTimeOffset now) { var start = now.AddHours(-2); var parameter = DurationParameter.WithStartAndDuration(start, null); TimeService.CurrentDateTime.Returns(now); var observer = TestScheduler.CreateObserver <DateTimeOffset>(); ViewModel.StartTime.Subscribe(observer); ViewModel.Prepare(new EditDurationParameters(parameter)); TestScheduler.Start(); observer.LastValue().Should().BeSameDateAs(start); }
public void Time() { var date = new DateTimeOffset(year: 2016, month: 4, day: 1, hour: 1, minute: 0, second: 0, offset: TimeSpan.Zero); EqualityUnit .Create(new DateTimeKey(date, DateTimeKeyFlags.Time)) .WithEqualValues( new DateTimeKey(date, DateTimeKeyFlags.Time), new DateTimeKey(date.AddDays(1), DateTimeKeyFlags.Time)) .WithNotEqualValues( new DateTimeKey(date, DateTimeKeyFlags.Date), new DateTimeKey(date.AddHours(1), DateTimeKeyFlags.Time)) .RunAll( (x, y) => x == y, (x, y) => x != y); }
public static void TestAddition() { DateTimeOffset dt = new DateTimeOffset(new DateTime(1986, 8, 15, 10, 20, 5, 70)); Assert.Equal(17, dt.AddDays(2).Day); Assert.Equal(13, dt.AddDays(-2).Day); Assert.Equal(10, dt.AddMonths(2).Month); Assert.Equal(6, dt.AddMonths(-2).Month); Assert.Equal(1996, dt.AddYears(10).Year); Assert.Equal(1976, dt.AddYears(-10).Year); Assert.Equal(13, dt.AddHours(3).Hour); Assert.Equal(7, dt.AddHours(-3).Hour); Assert.Equal(25, dt.AddMinutes(5).Minute); Assert.Equal(15, dt.AddMinutes(-5).Minute); Assert.Equal(35, dt.AddSeconds(30).Second); Assert.Equal(2, dt.AddSeconds(-3).Second); Assert.Equal(80, dt.AddMilliseconds(10).Millisecond); Assert.Equal(60, dt.AddMilliseconds(-10).Millisecond); }
private static string GetParameter(ref DateTimeOffset startDateTimeOffset, int count, ProcessRequestBy processRequestBy) { switch (processRequestBy) { case ProcessRequestBy.Day: return("startDate=" + HttpUtility.UrlEncode(startDateTimeOffset.AddDays(count).ToString(_dateTimeOffsetFormat)) + "&endDate=" + HttpUtility.UrlEncode(startDateTimeOffset.AddDays(count + 1).ToString(_dateTimeOffsetFormat))); case ProcessRequestBy.Hour: return("startDate=" + HttpUtility.UrlEncode(startDateTimeOffset.AddHours(count).ToString(_dateTimeOffsetFormat)) + "&endDate=" + HttpUtility.UrlEncode(startDateTimeOffset.AddHours(count + 1).ToString(_dateTimeOffsetFormat))); case ProcessRequestBy.Second: return("startDate=" + HttpUtility.UrlEncode(startDateTimeOffset.AddSeconds(count).ToString(_dateTimeOffsetFormat)) + "&endDate=" + HttpUtility.UrlEncode(startDateTimeOffset.AddSeconds(count + 1).ToString(_dateTimeOffsetFormat))); } return(string.Empty); }
/// <summary> /// Testing RecurrentExample (see comment there) against a provided DateTimeOffset, /// trying what operations must be done to ensure that the DateTimeOffset is converted /// to the time as of the TimeZone rather than get it 'as is' (this will enable us to read /// database DateTimeOffsets that has an offset that doesn't match the Event or user time zone but /// must be converted to that before calculate occurrences). /// </summary> /// <returns></returns> static string OffsetRecurrentExample(string tz) { // We have a DateTime with an attached Offset, so the equivalent UTC time must be the same // on any tested time zone for a time not in the DST range, // it just changes the local value displayed and the calculations // of occurrences regarding DST (has or not DST, different DST date change). // Midday at UTC saved on UTC //var now = new DateTimeOffset(2016, 1, 1, 12, 0, 0, new TimeSpan(0, 0, 0)); // Midday at UTC saved at PST (America/Los_Angeles) // -- results must be the same as when saved as UTC with the corrected time, as opposite to // the RecurrentExample method var now = new DateTimeOffset(2016, 1, 1, 4, 0, 0, new TimeSpan(-8, 0, 0)); var later = now.AddHours(1); var rrule = new RecurrencePattern(FrequencyType.Monthly, 1) { Count = 12 }; var timezone = NodaTime.DateTimeZoneProviders.Tzdb.GetZoneOrNull(tz); var znow = new NodaTime.ZonedDateTime(NodaTime.Instant.FromDateTimeOffset(now), timezone); var start = new CalDateTime(znow.LocalDateTime.ToDateTimeUnspecified(), tz); //Console.WriteLine("timezone {0}, znow: {1}, start: {2}", timezone, znow, start); var e = new Event { DtStart = start, Duration = new TimeSpan(1, 0, 0), RecurrenceRules = new List <IRecurrencePattern> { rrule }, }; var calendar = new Calendar(); calendar.Events.Add(e); //var serializer = new CalendarSerializer(new SerializationContext()); //return serializer.SerializeToString(calendar); var endSearch = new DateTime(2017, 1, 1, 12, 0, 0).ToUniversalTime(); return(calendar.GetOccurrences(now.UtcDateTime, endSearch).Aggregate("", (ret, a) => { return ret + a.Period.StartTime.AsUtc.ToString() + "\n"; })); }
public async Task <List <WeatherRecordModel> > GetActualWeatherRecord(string accessToken, DateTimeOffset currentDate) { var client = new HttpClient(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken); //validating certificate to use https ServicePointManager.ServerCertificateValidationCallback = CertificateValidation.MyRemoteCertificateValidationCallback; var month = (int.Parse(currentDate.Day.ToString()) == 1 && int.Parse(currentDate.Minute.ToString()) >= 0 && int.Parse(currentDate.Minute.ToString()) < 20 && int.Parse(currentDate.Hour.ToString()) == 0) ? currentDate.AddMonths(-1).Month : currentDate.Month; var year = (int.Parse(currentDate.Month.ToString()) == 1 && int.Parse(currentDate.Day.ToString()) == 1 && int.Parse(currentDate.Minute.ToString()) >= 0 && int.Parse(currentDate.Minute.ToString()) < 20 && int.Parse(currentDate.Hour.ToString()) == 0) ? currentDate.AddYears(-1).Year : currentDate.Year; var day = (int.Parse(currentDate.Minute.ToString()) >= 0 && int.Parse(currentDate.Minute.ToString()) < 20 && int.Parse(currentDate.Hour.ToString()) == 0) ? currentDate.AddDays(-1).Day : currentDate.Day; var hour = (int.Parse(currentDate.Minute.ToString()) >= 0 && int.Parse(currentDate.Minute.ToString()) < 20) ? currentDate.AddHours(-1).Hour : currentDate.Hour; var url = Constants.GetWeatherRecordsUrl + year + "-" + month + "-" + day + "T" + hour.ToString("00.##") + ":" + currentDate.AddMinutes(-20).Minute.ToString("00.##") + ":00" + "/" + currentDate.Year + "-" + currentDate.Month + "-" + currentDate.Day + "T" + currentDate.Hour.ToString("00.##") + ":" + currentDate.Minute.ToString("00.##") + ":00"; List <WeatherRecordModel> weatherRecord; try { var json = await client.GetStringAsync(url); JObject jsonResponse = JObject.Parse(json); JArray objResponse = (JArray)jsonResponse["value"]; weatherRecord = JsonConvert.DeserializeObject <List <WeatherRecordModel> >(objResponse.ToString()); } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Exception Message : " + e.Message + " Instance that caused the current message : " + e.InnerException + " Stack of Exception :" + e.StackTrace); return(null); } return(weatherRecord); }
public async Task ReturnsFinishedPersistingResultWhenThereAreNoProjectsWhichNeedRefetchingAndWereNotUpdatedWithinTheLastTwentyFourHours() { setStoredProjects( new MockProject { WorkspaceId = 1, SyncStatus = SyncStatus.RefetchingNeeded, At = now.AddHours(-23) }, new MockProject { WorkspaceId = 1, SyncStatus = SyncStatus.RefetchingNeeded, At = now.AddHours(-10) }, new MockProject { WorkspaceId = 1, SyncStatus = SyncStatus.RefetchingNeeded, At = now.AddHours(-2) }, new MockProject { WorkspaceId = 1, SyncStatus = SyncStatus.RefetchingNeeded, At = now } ); var transition = await state.Start(fetch); transition.Result.Should().Be(state.Done); }
public async Task SchedulesEventsOnlyFromEnabledCalendars() { const int eventsPerCalendar = 4; var now = new DateTimeOffset(2020, 1, 2, 3, 4, 5, TimeSpan.Zero); IEnumerable <CalendarItem> eventsForCalendar(UserCalendar calendar) { return(Enumerable .Range(1, eventsPerCalendar) .Select(id => new CalendarItem( id.ToString(), CalendarItemSource.Calendar, now.AddHours(id), TimeSpan.FromHours(1), "description", CalendarIconKind.None, calendarId: calendar.Id ))); } var calendars = Enumerable .Range(0, 3) .Select(id => id.ToString()) .Select(id => new UserCalendar( id, id, "Does not matter" )) .ToArray(); CalendarService.GetUserCalendars().Returns(Observable.Return(calendars)); var events = calendars .SelectMany(eventsForCalendar); CalendarService .GetEventsInRange(Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>()) .Returns(Observable.Return(events)); UserPreferences.EnabledCalendarIds().Returns(new List <string> { "1" }); TimeService.CurrentDateTime.Returns(now); await interactor.Execute(); await NotificationService.Received().Schedule(Arg.Is <ImmutableList <Notification> >( notifications => notifications.Count == eventsPerCalendar )); }
public void SetsTheStopTimeToTheValueReturnedByTheSelectDateTimeDialogViewModelWhenEditingACompletedTimeEntry(DateTimeOffset now) { var start = now.AddHours(-4); var duration = TimeSpan.FromHours(1); var parameterToReturn = DurationParameter.WithStartAndDuration(start, duration); NavigationService .Navigate <EditDurationViewModel, DurationParameter, DurationParameter>(Arg.Any <DurationParameter>()) .Returns(parameterToReturn); ConfigureEditedTimeEntry(now); ViewModel.Prepare(Id); ViewModel.EditDurationCommand.ExecuteAsync().Wait(); ViewModel.Duration.Should().Be(parameterToReturn.Duration.Value); }
private bool checkTime(DateTimeOffset now, DateTimeOffset check) { if (DateTimeOffset.Compare(now, check) < 0) { return(false); } check = check.AddHours(2); if (DateTimeOffset.Compare(now, check) <= 0) { return(true); } else { return(false); } }
public ValueTask <bool> CreateShowCalendarInviteAsync(DocsShow show) { DateTimeOffset showTime = show.Date !.Value; string bodyText = $"<strong>🕚</strong> 30 mins before the show, work through the <a href='https://aka.ms/go-live-checklist'>go-live checklist</a>.<br>" + $"<strong>📺</strong> <a href='{show.GuestStreamUrl}'>Join the stream</a>.<br>" + $"<strong>👋</strong> <a href='https://dotnetdocs.dev/show/{show.Id}'>Share your episode to help boost viewership</a>."; return(PostJsonAsync(new { to = string.Join(";", show.Guests.Select(g => g.Email).Concat(new[] { "*****@*****.**" })), title = $"The .NET Docs Show: {show.Title}", body = bodyText, startTime = $"{showTime:yyyy-MM-ddThh:mm:ss}", endTime = $"{showTime.AddHours(1):yyyy-MM-ddThh:mm:ss}", },
internal AdmiralRankingPoints(Admiral rpAdmiral) { r_Owner = rpAdmiral; r_AdmiralID = rpAdmiral.ID; ApiService.SubscribeOnce("api_port/port", delegate { ReloadInitialRankingPoints(); PreviousUpdateDifference = new AdmiralRankingPointsDifference(this, AdmiralRankingPointsDifferenceType.PreviousUpdate); DayDifference = new AdmiralRankingPointsDifference(this, AdmiralRankingPointsDifferenceType.Day); MonthDifference = new AdmiralRankingPointsDifference(this, AdmiralRankingPointsDifferenceType.Month); Update(); var rRankUpdateTime = new DateTimeOffset(DateTimeOffset.Now.Date, TimeSpan.FromHours(6.0)); var rDayTimeSpan = TimeSpan.FromDays(1.0); Observable.Timer(rRankUpdateTime.AddDays(1.0), rDayTimeSpan).Subscribe(delegate { PreviousUpdateDifference.Reload(); DayDifference.Reload(); OnPropertyChanged(nameof(PreviousUpdateDifference)); OnPropertyChanged(nameof(DayDifference)); }); rRankUpdateTime += TimeSpan.FromHours(12.0); if (DateTimeOffset.Now > rRankUpdateTime) rRankUpdateTime += rDayTimeSpan; Observable.Timer(rRankUpdateTime, rDayTimeSpan).Subscribe(delegate { PreviousUpdateDifference.Reload(); OnPropertyChanged(nameof(PreviousUpdateDifference)); }); var rNow = DateTimeOffset.Now; var rFinalizationTime = new DateTimeOffset(rNow.Year, rNow.Month, 1, 0, 0, 0, TimeSpan.FromHours(9.0)).AddMonths(1).AddHours(-2.0); if (rNow >= rFinalizationTime) FinalizeThisMonth(); else Observable.Return(Unit.Default).Delay(rFinalizationTime).Subscribe(_ => FinalizeThisMonth()); Observable.Return(Unit.Default).Delay(rFinalizationTime.AddHours(2.0)).Subscribe(_ => r_IsFinalized = false); RecordService.Instance.Update += RecordService_Update; }); }
void Snippets() { #region Dividing var now = new DateTimeOffset(2013, 8, 13, 13, 0, 0, TimeSpan.FromHours(12)); var availableTime = new TimeRange(now, now.AddHours(1)); var freeSlots = availableTime.Divide(TimeSpan.FromMinutes(15)); foreach (var freeSlot in freeSlots) { Console.WriteLine(freeSlot); } // Produces 4 15 minute time ranges. // // 13 Aug 2013 1:00:00 p.m. +12:00 for 00:15:00 // 13 Aug 2013 1:15:00 p.m. +12:00 for 00:15:00 // 13 Aug 2013 1:30:00 p.m. +12:00 for 00:15:00 // 13 Aug 2013 1:45:00 p.m. +12:00 for 00:15:00 #endregion }
private static DateTimeOffset TranslatedAdd(DateTimeOffset date, IntervalUnit unit, int amountToAdd) { switch (unit) { case IntervalUnit.Day: return date.AddDays(amountToAdd); case IntervalUnit.Hour: return date.AddHours(amountToAdd); case IntervalUnit.Minute: return date.AddMinutes(amountToAdd); case IntervalUnit.Month: return date.AddMonths(amountToAdd); case IntervalUnit.Second: return date.AddSeconds(amountToAdd); case IntervalUnit.Millisecond: return date.AddMilliseconds(amountToAdd); case IntervalUnit.Week: return date.AddDays(amountToAdd*7); case IntervalUnit.Year: return date.AddYears(amountToAdd); default: throw new ArgumentException("Unknown IntervalUnit"); } }
public static DateTimeOffset Round(this DateTimeOffset dateTime, RoundTo rt) { DateTimeOffset rounded; switch (rt) { case RoundTo.Second: { rounded = new DateTimeOffset(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second,dateTime.Offset); if (dateTime.Millisecond >= 500) { rounded = rounded.AddSeconds(1); } break; } case RoundTo.Minute: { rounded = new DateTimeOffset(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, 0,dateTime.Offset); if (dateTime.Second >= 30) { rounded = rounded.AddMinutes(1); } break; } case RoundTo.Hour: { rounded = new DateTimeOffset(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, 0, 0,dateTime.Offset); if (dateTime.Minute >= 30) { rounded = rounded.AddHours(1); } break; } case RoundTo.Day: { rounded = new DateTimeOffset(dateTime.Year, dateTime.Month, dateTime.Day, 0, 0, 0,dateTime.Offset); if (dateTime.Hour >= 12) { rounded = rounded.AddDays(1); } break; } default: { throw new ArgumentOutOfRangeException("rt"); } } return rounded; }
public void When_date_is_not_at_least_one_day_before_another_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var target = new DateTimeOffset(2.October(2009), 0.Hours()); DateTimeOffset subject = target.AddHours(-23); //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeAtLeast(TimeSpan.FromDays(1)).Before(target, "we like {0}", "that"); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>().WithMessage( "Expected date and/or time <2009-10-01 01:00:00> to be at least 1d before <2009-10-02> because we like that, but it differs 23h."); }
public void TestHourlyIntervalGetFireTimeAfter() { DateTimeOffset startCalendar = new DateTimeOffset(2005, 6, 1, 9, 30, 17, TimeSpan.Zero); CalendarIntervalTriggerImpl yearlyTrigger = new CalendarIntervalTriggerImpl(); yearlyTrigger.StartTimeUtc = startCalendar; yearlyTrigger.RepeatIntervalUnit = IntervalUnit.Hour; yearlyTrigger.RepeatInterval = 100; // every 100 hours DateTimeOffset targetCalendar = new DateTimeOffset(2005, 6, 1, 9, 30, 17, TimeSpan.Zero); targetCalendar = targetCalendar.AddHours(400); // jump 400 hours (4 intervals) IList<DateTimeOffset> fireTimes = TriggerUtils.ComputeFireTimes(yearlyTrigger, null, 6); DateTimeOffset fifthTime = fireTimes[4]; // get the fifth fire time Assert.AreEqual(targetCalendar, fifthTime, "Hour increment result not as expected."); }
private async Task CreateTimerResults(TimerCounter timerCounter) { var userId = await GetUserId(); if (timerCounter == null) return; try { // remove previous results, if any var results = await _context.TimerResults.Where(e => e.TimerCounterId == timerCounter.TimerCounterId && e.DiteUserId == userId).ToListAsync(); if (results != null) _context.TimerResults.RemoveRange(results); } catch (Exception ex) { // required connection string parameter - MultipleActiveResultSets=True throw new Exception("error removing old results", ex); } DateTimeOffset localStart = timerCounter.TimerStartLocal; DateTimeOffset localEnd = timerCounter.TimerEndLocal; // first end var nextEnd = new DateTimeOffset(localStart.Year, localStart.Month, localStart.Day, localStart.Hour, 0, 0, localStart.Offset); nextEnd = nextEnd.AddHours(1); if(nextEnd>localEnd) { // within same hour; only result TimerResult result = NewTimerResult(timerCounter, userId, localStart, localEnd); _context.TimerResults.Add(result); return; } else { // first hour; first result TimerResult result = NewTimerResult(timerCounter, userId, localStart, nextEnd); _context.TimerResults.Add(result); // sequence var nextStart = new DateTimeOffset(localStart.Year, localStart.Month, localStart.Day, localStart.Hour, 0, 0, localStart.Offset); while ((nextStart = nextStart.AddHours(1)) < localEnd && ((nextEnd = nextEnd.AddHours(1)) < localEnd)) { var seqResult = NewTimerResult(timerCounter, userId, nextStart, nextEnd); _context.TimerResults.Add(seqResult); } // last hour; last result TimerResult resultLast = NewTimerResult(timerCounter, userId, nextStart, localEnd); _context.TimerResults.Add(resultLast); } }
public static CharacterModel GetCharacter(RegionsLookup region, string server, string name) { string key = string.Format("character_{0}_{1}_{2}", region, server, name); ObjectCache cache = MemoryCache.Default; CharacterModel item = cache[key] as CharacterModel; if (item == null) { string requestUrl = string.Format("{0}/character/{1}/{2}", GetBaseRequestURL(region), server, name); try { WebClient client = new WebClient(); string result = client.DownloadString(requestUrl); DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(CharacterModel)); using (MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(result))) { item = serializer.ReadObject(ms) as CharacterModel; } DateTimeOffset dto = new DateTimeOffset(); dto.AddHours(1); cache.Set(key, item, DateTimeOffset.Now.AddMinutes(30)); } catch (Exception ex) { } } return item; }
public IHttpActionResult ResetDataSource() { DateAndTimeOfDayContext db = new DateAndTimeOfDayContext(); if (!db.Customers.Any()) { DateTimeOffset dateTime = new DateTimeOffset(2014, 12, 24, 1, 2, 3, 4, new TimeSpan(-8, 0, 0)); IEnumerable<EfCustomer> customers = Enumerable.Range(1, 5).Select(e => new EfCustomer { Id = e, DateTime = dateTime.AddYears(e).AddHours(e).AddMilliseconds(e).DateTime, NullableDateTime = e % 2 == 0 ? (DateTime?)null : dateTime.AddHours(e * 5).AddMilliseconds(e * 5).DateTime, Offset = dateTime.AddMonths(e).AddHours(e).AddMilliseconds(e), NullableOffset = e % 3 == 0 ? (DateTimeOffset?)null : dateTime.AddDays(e).AddHours(e * 5) }).ToList(); foreach (EfCustomer customer in customers) { db.Customers.Add(customer); } db.SaveChanges(); } return Ok(); }
public static void AddHours(DateTimeOffset dateTimeOffset, double hours, DateTimeOffset expected) { Assert.Equal(expected, dateTimeOffset.AddHours(hours)); }
public void When_date_is_at_least_one_day_before_another_it_should_not_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var target = new DateTimeOffset(2.October(2009)); DateTimeOffset subject = target.AddHours(-24); //----------------------------------------------------------------------------------------------------------- // Act / Assert //----------------------------------------------------------------------------------------------------------- subject.Should().BeAtLeast(TimeSpan.FromDays(1)).Before(target); }
/// <summary> /// Initializes a new instance of the <see cref="OneTimeToken"/> class. /// Recreates a previously issued token for verification /// </summary> /// <param name="key">The key.</param> /// <param name="tokenStamp">The token stamp.</param> /// <param name="expiration">The expiration.</param> /// <exception cref="ArgumentNullException"> /// </exception> public OneTimeToken(byte[] key, byte[] tokenStamp, DateTimeOffset expiration) { if (key != null || key.Length <= 0) { _hmacSha = new HMACSHA256(key); if (tokenStamp != null || tokenStamp.Length <= 0) { TokenStamp = tokenStamp; } else { throw new ArgumentNullException(nameof(tokenStamp)); } _rng = System.Security.Cryptography.RandomNumberGenerator.Create(); _issueTime = expiration.AddHours(-1); } else { throw new ArgumentNullException(nameof(key)); } }
public void Subtracting() { var now = new DateTimeOffset(2013, 8, 13, 13, 0, 0, TimeSpan.FromHours(12)); var tick = new TimeSpan(1); var time = new TimeRange(now, now.AddHours(1)); var before = new TimeRange(now - TimeSpan.FromHours(1), time.StartsOn); var after = new TimeRange(time.EndsOn, TimeSpan.FromHours(1)); var mid = new TimeRange(now.AddMinutes(15), TimeSpan.FromMinutes(30)); // No intersection Assert.AreEqual(1, time.Subtract(before).Count()); Assert.AreEqual(time, time.Subtract(before).First()); Assert.AreEqual(1, time.Subtract(after).Count()); Assert.AreEqual(time, time.Subtract(after).First()); // Identity Assert.AreEqual(0, time.Subtract(time).Count()); // Subsumes Assert.AreEqual(0, time.Subtract(new TimeRange(before.StartsOn, after.EndsOn)).Count()); // Middle Assert.AreEqual(2, time.Subtract(mid).Count()); Assert.IsTrue(time.Subtract(mid).Any(t => t.StartsOn == now && t.Duration == TimeSpan.FromMinutes(15))); Assert.IsTrue(time.Subtract(mid).Any(t => t.StartsOn == now.AddMinutes(45) && t.Duration == TimeSpan.FromMinutes(15))); }
public void When_date_is_not_within_50_hours_before_another_date_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var target = new DateTimeOffset(10.April(2010).At(12, 0), 0.Hours()); DateTimeOffset subject = target.AddHours(-50).AddSeconds(-1); //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeWithin(TimeSpan.FromHours(50)).Before(target, "{0} hours is enough", 50); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>().WithMessage( "Expected date and/or time <2010-04-08 09:59:59> to be within 2d and 2h before <2010-04-10 12:00:00> because 50 hours is enough, but it differs 2d, 2h and 1s."); }
/// <summary> /// Returns an enumerable collection of log blobs containing Analytics log records. The blobs are retrieved lazily. /// </summary> /// <param name="service">A <see cref="StorageService"/> enumeration value.</param> /// <param name="startTime">A <see cref="DateTimeOffset"/> object representing the start of the time range for which logs should be retrieved.</param> /// <param name="endTime">A <see cref="DateTimeOffset"/> object representing the end of the time range for which logs should be retrieved.</param> /// <param name="operations">A <see cref="LoggingOperations"/> enumeration value that indicates the types of logging operations on which to filter the log blobs.</param> /// <param name="details">A <see cref="BlobListingDetails"/> enumeration value that indicates whether or not blob metadata should be returned. Only <c>None</c> and <c>Metadata</c> are valid values. </param> /// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> /// <returns>An enumerable collection of objects that implement <see cref="ICloudBlob"/> and are retrieved lazily.</returns> /// <remarks>Note that specifying a logging operation type for the <paramref name="operations"/> parameter will return any Analytics log blob that contains the specified logging operation, /// even if that log blob also includes other types of logging operations. Also note that the only currently supported values for the <paramref name="details"/> /// parameter are <c>None</c> and <c>Metadata</c>.</remarks> public IEnumerable<ICloudBlob> ListLogs(StorageService service, DateTimeOffset startTime, DateTimeOffset? endTime, LoggingOperations operations, BlobListingDetails details, BlobRequestOptions options, OperationContext operationContext) { CloudBlobDirectory logDirectory = this.GetLogDirectory(service); BlobListingDetails metadataDetails = details; DateTimeOffset utcStartTime = startTime.ToUniversalTime(); DateTimeOffset dateCounter = new DateTimeOffset(utcStartTime.Ticks - (utcStartTime.Ticks % TimeSpan.TicksPerHour), utcStartTime.Offset); DateTimeOffset? utcEndTime = null; string endPrefix = null; // Ensure that the date range is correct. if (endTime.HasValue) { utcEndTime = endTime.Value.ToUniversalTime(); endPrefix = logDirectory.Prefix + utcEndTime.Value.ToString("yyyy/MM/dd/HH", CultureInfo.InvariantCulture); if (utcStartTime > utcEndTime.Value) { string errorString = string.Format(CultureInfo.InvariantCulture, SR.StartTimeExceedsEndTime, startTime, endTime.Value); throw new ArgumentException(errorString); } } // Currently only support the ability to retrieve metadata on logs. if (details.HasFlag(BlobListingDetails.Copy) || details.HasFlag(BlobListingDetails.Snapshots) || details.HasFlag(BlobListingDetails.UncommittedBlobs)) { throw new ArgumentException(SR.InvalidListingDetails); } // At least one LogType must be specified. if (operations == LoggingOperations.None) { throw new ArgumentException(SR.InvalidLoggingLevel); } // If metadata or a specific LogType is specified, metadata should be retrieved. if (details.HasFlag(BlobListingDetails.Metadata) || !operations.HasFlag(LoggingOperations.All)) { metadataDetails = BlobListingDetails.Metadata; } // Check logs using an hour-based prefix until we reach a day boundary. while (dateCounter.Hour > 0) { string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy/MM/dd/HH", CultureInfo.InvariantCulture); IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext); foreach (ICloudBlob log in currentLogs) { if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0) { if (IsCorrectLogType(log, operations)) { yield return log; } } else { yield break; } } dateCounter = dateCounter.AddHours(1); if (dateCounter > DateTimeOffset.UtcNow.AddHours(1)) { yield break; } } // Check logs using a day-based prefix until we reach a month boundary. while (dateCounter.Day > 1) { string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy/MM/dd", CultureInfo.InvariantCulture); IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext); foreach (ICloudBlob log in currentLogs) { if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0) { if (IsCorrectLogType(log, operations)) { yield return log; } } else { yield break; } } dateCounter = dateCounter.AddDays(1); if (dateCounter > DateTimeOffset.UtcNow.AddHours(1)) { yield break; } } // Check logs using a month-based prefix until we reach a year boundary. while (dateCounter.Month > 1) { string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy/MM", CultureInfo.InvariantCulture); IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext); foreach (ICloudBlob log in currentLogs) { if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0) { if (IsCorrectLogType(log, operations)) { yield return log; } } else { yield break; } } dateCounter = dateCounter.AddMonths(1); if (dateCounter > DateTimeOffset.UtcNow.AddHours(1)) { yield break; } } // Continue using a year-based prefix. while (true) { string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy", CultureInfo.InvariantCulture); IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext); foreach (ICloudBlob log in currentLogs) { if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0) { if (IsCorrectLogType(log, operations)) { yield return log; } } else { yield break; } } dateCounter = dateCounter.AddYears(1); if (dateCounter > DateTimeOffset.UtcNow.AddHours(1)) { yield break; } } }
public void TestTimeZone() { TimeZoneInfo GMT = TimeZoneInfo.FindSystemTimeZoneById("GMT Standard Time"); TimeZoneInfo EST = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"); // Calendar startTime = Calendar.getInstance(EST); var startTime = new DateTime(2006, 3, 7, 7, 0, 0, DateTimeKind.Utc); startTime = TimeZoneInfo.ConvertTimeFromUtc(startTime, EST); // Same timezone { NthIncludedDayTrigger t = new NthIncludedDayTrigger("name", "group"); t.IntervalType = NthIncludedDayTrigger.IntervalTypeWeekly; t.N = 3; t.StartTimeUtc = startTime.ToUniversalTime(); t.FireAtTime = "8:00"; t.TimeZone = EST; DateTimeOffset? firstTime = t.ComputeFirstFireTimeUtc(null); // Calendar firstTimeCal = Calendar.getInstance(EST); DateTime firstTimeCal = new DateTime(startTime.Year, startTime.Month, startTime.Day, 8, 0, 0, 0, DateTimeKind.Utc); firstTimeCal = TimeZoneInfo.ConvertTimeFromUtc(firstTimeCal, EST); //roll start date forward to first day of the next week while (firstTimeCal.DayOfWeek != t.TriggerCalendarFirstDayOfWeek) { firstTimeCal = firstTimeCal.AddDays(-1); } //first day of the week counts as one. add two more to get N=3. firstTimeCal = firstTimeCal.AddDays(2); //if we went back too far, shift forward a week. if (firstTimeCal < startTime) { firstTimeCal = firstTimeCal.AddDays(7); } Assert.AreEqual(firstTime, firstTimeCal); } // Different timezones { NthIncludedDayTrigger t = new NthIncludedDayTrigger("name", "group"); t.IntervalType = NthIncludedDayTrigger.IntervalTypeWeekly; t.N = 3; t.StartTimeUtc = startTime; t.FireAtTime = "8:00"; t.TimeZone = GMT; DateTimeOffset? firstTime = t.ComputeFirstFireTimeUtc(null); // Calendar firstTimeCal = Calendar.getInstance(EST); DateTimeOffset firstTimeCal = new DateTimeOffset(startTime.Year, startTime.Month, startTime.Day, 8, 0, 0, 0, TimeSpan.Zero); //EST is GMT-5 firstTimeCal.AddHours(-5); //roll start date forward to first day of the next week while (firstTimeCal.DayOfWeek != t.TriggerCalendarFirstDayOfWeek) { firstTimeCal = firstTimeCal.AddDays(-1); } //first day of the week counts as one. add two more to get N=3. firstTimeCal = firstTimeCal.AddDays(2); //if we went back too far, shift forward a week. if (firstTimeCal < startTime) { firstTimeCal = firstTimeCal.AddDays(7); } Assert.AreEqual(firstTime, firstTimeCal); } }
public void When_a_value_is_not_one_of_the_specified_values_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var value = new DateTimeOffset(31.December(2016), 1.Hours()); //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action action = () => value.Should().BeOneOf(value.AddDays(1), value.AddHours(4)); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- action.ShouldThrow<AssertFailedException>() .WithMessage("Expected value to be one of {<2017-01-01 +1h>, <2016-12-31 04:00:00 +1h>}, but found <2016-12-31 +1h>."); }
public void ToRelativeTimeTest() { var date = new DateTimeOffset(2015, 8, 7, 13, 26, 30, TimeSpan.Zero); var now = DateTimeOffset.Now; Assert.AreEqual("now", now.ToRelativeTimeString()); Assert.AreEqual("now", now.ToRelativeTimeString(now)); Assert.AreEqual("1 second ago", date.AddSeconds(-1).ToRelativeTimeString(date)); Assert.AreEqual("10 seconds ago", date.AddSeconds(-10).ToRelativeTimeString(date)); Assert.AreEqual("1 minute ago", date.AddSeconds(-90).ToRelativeTimeString(date)); Assert.AreEqual("1 minute ago", date.AddSeconds(-100).ToRelativeTimeString(date)); Assert.AreEqual("2 minutes ago", date.AddSeconds(-120).ToRelativeTimeString(date)); Assert.AreEqual("7 minutes ago", date.AddMinutes(-7).ToRelativeTimeString(date)); Assert.AreEqual("59 minutes ago", date.AddMinutes(-59).ToRelativeTimeString(date)); Assert.AreEqual("1 hour ago", date.AddMinutes(-60).ToRelativeTimeString(date)); Assert.AreEqual("1 hour ago", date.AddHours(-1).ToRelativeTimeString(date)); Assert.AreEqual("9 hours ago", date.AddHours(-9).ToRelativeTimeString(date)); Assert.AreEqual("1 day ago", date.AddHours(-24).ToRelativeTimeString(date)); Assert.AreEqual("1 day ago", date.AddHours(-30).ToRelativeTimeString(date)); Assert.AreEqual("2 days ago", date.AddHours(-48).ToRelativeTimeString(date)); Assert.AreEqual("1 day ago", date.AddDays(-1).ToRelativeTimeString(date)); Assert.AreEqual("12 days ago", date.AddDays(-12).ToRelativeTimeString(date)); Assert.AreEqual("29 days ago", date.AddDays(-29).ToRelativeTimeString(date)); Assert.AreEqual("1 month ago", date.AddDays(-30).ToRelativeTimeString(date)); Assert.AreEqual("1 month ago", date.AddMonths(-1).ToRelativeTimeString(date)); Assert.AreEqual("3 months ago", date.AddMonths(-3).ToRelativeTimeString(date)); Assert.AreEqual("11 months ago", date.AddMonths(-11).ToRelativeTimeString(date)); Assert.AreEqual("1 year ago", date.AddMonths(-12).ToRelativeTimeString(date)); Assert.AreEqual("1 year ago", date.AddYears(-1).ToRelativeTimeString(date)); Assert.AreEqual("3 years ago", date.AddYears(-3).ToRelativeTimeString(date)); Assert.AreEqual("1 second from now", date.AddSeconds(1).ToRelativeTimeString(date)); Assert.AreEqual("10 seconds from now", date.AddSeconds(10).ToRelativeTimeString(date)); Assert.AreEqual("1 minute from now", date.AddSeconds(90).ToRelativeTimeString(date)); Assert.AreEqual("1 minute from now", date.AddSeconds(100).ToRelativeTimeString(date)); Assert.AreEqual("2 minutes from now", date.AddSeconds(120).ToRelativeTimeString(date)); Assert.AreEqual("7 minutes from now", date.AddMinutes(7).ToRelativeTimeString(date)); Assert.AreEqual("59 minutes from now", date.AddMinutes(59).ToRelativeTimeString(date)); Assert.AreEqual("1 hour from now", date.AddMinutes(60).ToRelativeTimeString(date)); Assert.AreEqual("1 hour from now", date.AddHours(1).ToRelativeTimeString(date)); Assert.AreEqual("9 hours from now", date.AddHours(9).ToRelativeTimeString(date)); Assert.AreEqual("1 day from now", date.AddDays(1).ToRelativeTimeString(date)); Assert.AreEqual("1 day from now", date.AddHours(24).ToRelativeTimeString(date)); Assert.AreEqual("12 days from now", date.AddDays(12).ToRelativeTimeString(date)); Assert.AreEqual("29 days from now", date.AddDays(29).ToRelativeTimeString(date)); Assert.AreEqual("1 month from now", date.AddDays(30).ToRelativeTimeString(date)); Assert.AreEqual("1 month from now", date.AddMonths(1).ToRelativeTimeString(date)); Assert.AreEqual("3 months from now", date.AddMonths(3).ToRelativeTimeString(date)); Assert.AreEqual("11 months from now", date.AddMonths(11).ToRelativeTimeString(date)); Assert.AreEqual("1 year from now", date.AddMonths(12).ToRelativeTimeString(date)); Assert.AreEqual("1 year from now", date.AddYears(1).ToRelativeTimeString(date)); Assert.AreEqual("3 years from now", date.AddYears(3).ToRelativeTimeString(date)); }
public void When_date_is_more_than_the_required_one_day_before_another_it_should_not_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var target = new DateTimeOffset(2.October(2009)); DateTimeOffset subject = target.AddHours(-25); //----------------------------------------------------------------------------------------------------------- // Act / Assert //----------------------------------------------------------------------------------------------------------- subject.Should().BeMoreThan(TimeSpan.FromDays(1)).Before(target); }
public void When_date_is_within_1d_before_another_date_it_should_not_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var target = new DateTimeOffset(10.April(2010)); DateTimeOffset subject = target.AddHours(-23); //----------------------------------------------------------------------------------------------------------- // Act / Assert //----------------------------------------------------------------------------------------------------------- subject.Should().BeWithin(TimeSpan.FromHours(24)).Before(target); }