public void TestOffset()
        {
            var testScheduler = new TestScheduler();
            var recorder = testScheduler.CreateObserver<int>();

            var notifier = new ScheduledNotifier<int>(testScheduler);
            notifier.Subscribe(recorder);

            var origin = new DateTimeOffset(1999, 1, 1, 1, 1, 1, TimeSpan.Zero);

            notifier.Report(1);
            notifier.Report(2);
            notifier.Report(3, origin);
            notifier.Report(4, origin.AddDays(10));
            notifier.Report(5, origin.AddYears(1));
            notifier.Report(6);

            testScheduler.Start();

            recorder.Messages.Is(
                OnNext(1, 1),
                OnNext(1, 2),
                OnNext(1, 6),
                OnNext(origin.Ticks, 3),
                OnNext(origin.AddDays(10).Ticks, 4),
                OnNext(origin.AddYears(1).Ticks, 5));
        }
        public void SetUp()
        {
            fileSystem = Substitute.For<ICalamariFileSystem>();
            deploymentJournal = Substitute.For<IDeploymentJournal>();
            clock = Substitute.For<IClock>();
            retentionPolicy = new RetentionPolicy(fileSystem, deploymentJournal, clock);

            now = new DateTimeOffset(new DateTime(2015, 01, 15), new TimeSpan(0, 0, 0));
            clock.GetUtcTime().Returns(now);

            // Deployed 4 days prior to 'now'
            fourDayOldDeployment = new JournalEntry("fourDayOld", "blah", "blah", "blah", "blah", policySet1,
                now.AddDays(-4).LocalDateTime,
                "C:\\packages\\Acme.1.0.0.nupkg", "C:\\Applications\\Acme.1.0.0", null, true);

            // Deployed 3 days prior to 'now'
            threeDayOldDeployment = new JournalEntry("threeDayOld", "blah", "blah", "blah", "blah", policySet1,
                now.AddDays(-3).LocalDateTime,
                "C:\\packages\\Acme.1.1.0.nupkg", "C:\\Applications\\Acme.1.1.0", null, true);

            // Deployed 2 days prior to 'now'
            twoDayOldDeployment = new JournalEntry("twoDayOld", "blah", "blah", "blah", "blah", policySet1,
                now.AddDays(-2).LocalDateTime,
                "C:\\packages\\Acme.1.2.0.nupkg", "C:\\Applications\\Acme.1.2.0", null, true);

            // Deployed (unsuccessfully) 1 day prior to 'now'
            oneDayOldUnsuccessfulDeployment = new JournalEntry("oneDayOldUnsuccessful", "blah", "blah", "blah", "blah", policySet1,
                now.AddDays(-1).LocalDateTime,
                "C:\\packages\\Acme.1.3.0.nupkg", "C:\\Applications\\Acme.1.3.0", null, false);

            // Deployed 5 days prior to 'now', but has a different policy-set
            fiveDayOldNonMatchingDeployment = new JournalEntry("fiveDayOld", "blah", "blah", "blah", "blah", policySet2,
                now.AddDays(-5).LocalDateTime,
                "C:\\packages\\Beta.1.0.0.nupkg", "C:\\Applications\\Beta.1.0.0", null, true);

            var journalEntries = new List<JournalEntry>
            {
                fiveDayOldNonMatchingDeployment,
                fourDayOldDeployment,
                threeDayOldDeployment,
                twoDayOldDeployment,
                oneDayOldUnsuccessfulDeployment
            };

            deploymentJournal.GetAllJournalEntries().Returns(journalEntries);

            foreach (var journalEntry in journalEntries)
            {
                fileSystem.FileExists(journalEntry.ExtractedFrom).Returns(true);
                fileSystem.DirectoryExists(journalEntry.ExtractedTo).Returns(true);
            }
        }
    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));
    }
 protected override List <IWorkspace> CreateComplexListWhereTheLastUpdateEntityIsDeleted(DateTimeOffset?at)
 => new List <IWorkspace>
 {
     new Workspace {
         At = at?.AddDays(-1), Name = Guid.NewGuid().ToString()
     },
     new Workspace {
         At = at?.AddDays(-3), Name = Guid.NewGuid().ToString()
     },
     new Workspace {
         At = at, ServerDeletedAt = at, Name = Guid.NewGuid().ToString()
     },
     new Workspace {
         At = at?.AddDays(-2), Name = Guid.NewGuid().ToString()
     }
 };
 public async Task UsesCustomPropertyNames()
 {
     try
     {
         await new HttpClient().GetStringAsync("http://i.do.not.exist");
     }
     catch (Exception e)
     {
         var timestamp = new DateTimeOffset(2013, 05, 28, 22, 10, 20, 666, TimeSpan.FromHours(10));
         var messageTemplate = "{Song}++";
         var template = new MessageTemplateParser().Parse(messageTemplate);
         using (var sink = new ElasticsearchSink(_options))
         {
             var properties = new List<LogEventProperty>
             {
                 new LogEventProperty("Song", new ScalarValue("New Macabre")), 
                 new LogEventProperty("Complex", new ScalarValue(new { A = 1, B = 2 }))
             };
             var logEvent = new LogEvent(timestamp, LogEventLevel.Information, e, template, properties);
             sink.Emit(logEvent);
             logEvent = new LogEvent(timestamp.AddDays(2), LogEventLevel.Information, e, template, properties);
             sink.Emit(logEvent);
         }
         _seenHttpPosts.Should().NotBeEmpty().And.HaveCount(1);
         var json = _seenHttpPosts.First();
         var bulkJsonPieces = json.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
         bulkJsonPieces.Should().HaveCount(4);
         bulkJsonPieces[0].Should().Contain(@"""_index"":""logstash-2013.05.28");
         bulkJsonPieces[1].Should().Contain("New Macabre");
         bulkJsonPieces[1].Should().NotContain("Properties\"");
         bulkJsonPieces[1].Should().Contain("fields\":{");
         bulkJsonPieces[1].Should().Contain("@timestamp");
         bulkJsonPieces[2].Should().Contain(@"""_index"":""logstash-2013.05.30");
     }
 }
Example #6
0
		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 async Task Synchronize_WhenLastSynchronizationTimeIsMoreRecentThanFileModificationDate_ShouldNotCallTranscode(
			double daysToAdd,
			[Frozen]Mock<ISynchronizedFilesRepository> synchronizedFileRepository,
			[Frozen]Mock<IFileTranscoder> fileTranscoder,
			MusicMirrorConfiguration config,
			FileSynchronizer sut,
			SourceFilePath sourceFile,
			TargetFilePath targetFile)
		{
			//arrange
			var lastWriteTime = new DateTimeOffset(2015, 04, 01, 0, 0, 0, TimeSpan.Zero);
			var lastSyncTime = lastWriteTime.AddDays(daysToAdd);
			sourceFile.LastWriteTime = lastWriteTime;
			synchronizedFileRepository.Setup(s => s.GetMirroredFilePath(It.IsAny<CancellationToken>(), sourceFile.File)).ReturnsTask(targetFile.File);
			synchronizedFileRepository.Setup(s => s.GetLastSynchronization(It.IsAny<CancellationToken>(), sourceFile.File)).ReturnsTask(lastSyncTime);
			//act
			await sut.Synchronize(CancellationToken.None, sourceFile);
			//assert
			fileTranscoder.Verify(f =>
				f.Transcode(
					It.IsAny<CancellationToken>(),
					sourceFile.File,
					AudioFormat.Flac,
					It.Is((DirectoryInfo d) => d.FullName.Equals(targetFile.File.DirectoryName))),
				Times.Never());
		}
 protected override List <ITask> CreateComplexListWhereTheLastUpdateEntityIsDeleted(DateTimeOffset?at)
 => new List <ITask>
 {
     new Task {
         At = at?.AddDays(-1) ?? DateTimeOffset.Now, Name = Guid.NewGuid().ToString()
     },
     new Task {
         At = at?.AddDays(-3) ?? DateTimeOffset.Now, Name = Guid.NewGuid().ToString()
     },
     new Task {
         At = at ?? DateTimeOffset.Now, Name = Guid.NewGuid().ToString()
     },
     new Task {
         At = at?.AddDays(-2) ?? DateTimeOffset.Now, Name = Guid.NewGuid().ToString()
     }
 };
 protected override List <IProject> CreateComplexListWhereTheLastUpdateEntityIsDeleted(DateTimeOffset?at)
 => new List <IProject>
 {
     new Project {
         At = at?.AddDays(-1) ?? Now, Name = Guid.NewGuid().ToString()
     },
     new Project {
         At = at?.AddDays(-3) ?? Now, Name = Guid.NewGuid().ToString()
     },
     new Project {
         At = at ?? Now, ServerDeletedAt = at, Name = Guid.NewGuid().ToString()
     },
     new Project {
         At = at?.AddDays(-2) ?? Now, Name = Guid.NewGuid().ToString()
     }
 };
        public async Task UsesCustomPropertyNames()
        {
            try
            {
                await this.ThrowAsync();
            }
            catch (Exception e)
            {
                var timestamp = new DateTimeOffset(2013, 05, 28, 22, 10, 20, 666, TimeSpan.FromHours(10));
                var messageTemplate = "{Song}++";
                var template = new MessageTemplateParser().Parse(messageTemplate);
                using (var sink = new ElasticsearchSink(_options))
                {
                    var properties = new List<LogEventProperty>
                    {
                        new LogEventProperty("Song", new ScalarValue("New Macabre")), 
                        new LogEventProperty("Complex", new ScalarValue(new { A = 1, B = 2 }))
                    };
                    var logEvent = new LogEvent(timestamp, LogEventLevel.Information, e, template, properties);
                    //one off
                    sink.Emit(logEvent);

                    sink.Emit(logEvent);
                    logEvent = new LogEvent(timestamp.AddDays(2), LogEventLevel.Information, e, template, properties);
                    sink.Emit(logEvent);
                }
                var bulkJsonPieces = this.AssertSeenHttpPosts(_seenHttpPosts, 4);
                bulkJsonPieces[0].Should().Contain(@"""_index"":""logstash-2013.05.28");
                bulkJsonPieces[1].Should().Contain("New Macabre");
                bulkJsonPieces[1].Should().NotContain("Properties\"");
                bulkJsonPieces[1].Should().Contain("fields\":{");
                bulkJsonPieces[1].Should().Contain("@timestamp");
                bulkJsonPieces[2].Should().Contain(@"""_index"":""logstash-2013.05.30");
            }
        }
Example #11
0
        public static int GetIdOfFirstPostOfDay(DateTimeOffset day)
        {
            var items = Query(
                $"/2.2/posts",
                $"pagesize=1&order=asc&min={day.ToUnixTimeSeconds()}&max={day.AddDays(1).ToUnixTimeSeconds()}&sort=creation").Result;

            return items[0].post_id;
        }
Example #12
0
 public void TestWeekDayExclusion()
 {
     // this is friday
     DateTimeOffset excluded = new DateTimeOffset(2007, 8, 3, 0, 0, 0, TimeSpan.Zero);
     cal.SetDayExcluded(DayOfWeek.Friday, true);
     // next monday should be next possible
     Assert.AreEqual(excluded.AddDays(3), cal.GetNextIncludedTimeUtc(excluded));
 }
        public async Task<IEnumerable<Meeting>> GetCalendarEvents(DateTimeOffset date)
        {
            string uri = BuildCalendarUri(date, date.AddDays(1));

            var items = await new HttpHelper().GetItemsAsync<Meeting>(uri);

            return items ?? new List<Meeting>();
        }
        public async Task CreateReturnsEditView_When_ActivityStartDateBeforeCampaignStartDate()
        {
            var campaignStartDate = new DateTimeOffset(new DateTime(1900, 1, 1));
            var campaignEndDate = campaignStartDate.AddDays(4);
            var sut = GetActivityController(campaignStartDate, campaignEndDate);
            var activityModel = new ActivityDetailModel
            {
                EndDateTime = campaignStartDate,
                StartDateTime = campaignStartDate.AddDays(-1)
            };

            var result = (ViewResult)await sut.Create(1, activityModel, null);

            Assert.Equal("Edit", result.ViewName);
            var errors = sut.ModelState.GetErrorMessages();
            Assert.Equal(1, errors.Count);
            Assert.Equal("Start date cannot be earlier than the campaign start date " + campaignStartDate.ToString("d"), errors[0]);
        }
Example #15
0
        public void CanAddDaysAcrossDstTransition_LandInOverlap()
        {
            var tz = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
            var dto = new DateTimeOffset(2015, 10, 31, 1, 30, 0, TimeSpan.FromHours(-7));
            var result = dto.AddDays(1, tz);

            var expected = new DateTimeOffset(2015, 11, 1, 1, 30, 0, TimeSpan.FromHours(-7));
            Assert.Equal(expected, result);
            Assert.Equal(expected.Offset, result.Offset);
        }
Example #16
0
        public void CanAddDaysAcrossDstTransition_StartWithMismatchedOffset()
        {
            var tz = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
            var dto = new DateTimeOffset(2015, 3, 8, 4, 0, 0, TimeSpan.FromHours(-4));
            var result = dto.AddDays(1, tz);

            var expected = new DateTimeOffset(2015, 3, 9, 0, 0, 0, TimeSpan.FromHours(-7));
            Assert.Equal(expected, result);
            Assert.Equal(expected.Offset, result.Offset);
        }
        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();
        }
Example #18
0
        private DateTimeOffset CalculatePhaseTimes(TimeUnit timeUnit, DateTimeOffset?startTime = null, bool doForward = true)
        {
            int length = timeUnit.Length;

            if (!doForward)
            {
                length *= -1;
            }

            switch (timeUnit.Unit)
            {
            case TimeUnitsType.Day:
                return(startTime?.AddDays(length) ?? ExecutionStart.AddDays(length));

            case TimeUnitsType.Week:
                return(startTime?.AddDays(length * 7) ?? ExecutionStart.AddDays(length * 7));

            case TimeUnitsType.Month:
                return(startTime?.AddMonths(length) ?? ExecutionStart.AddMonths(length));
            }
            return(DateTime.Now);
        }
        public void TestTimesForYear()
        {
            PrayerTimesCalculator calc = new PrayerTimesCalculator(47.660918, -122.136371);
            calc.CalculationMethod = CalculationMethods.ISNA;
            calc.AsrJurusticMethod = AsrJuristicMethods.Shafii;
            var times = new Times[365];
            for (int i = 0; i < 365; i ++)
            {
                var date = new DateTimeOffset(new DateTime(2015, 1, 1));
                times[i] = calc.GetPrayerTimes(date.AddDays(i), -7);
            }

            Assert.Equal(new DateTime(2015, 2, 3), times[33].Date);
            Assert.Equal(new TimeSpan(6, 8, 0), times[33].Fajr);
        }
Example #20
0
 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);
 }
Example #21
0
    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);
    }
        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;
            });
        }
        public void TestDailyIntervalGetFireTimeAfter()
        {
            DateTimeOffset startCalendar = new DateTimeOffset(2005, 6, 1, 9, 30, 17, TimeSpan.Zero);

            CalendarIntervalTriggerImpl dailyTrigger = new CalendarIntervalTriggerImpl();
            dailyTrigger.StartTimeUtc = startCalendar;
            dailyTrigger.RepeatIntervalUnit = IntervalUnit.Day;
            dailyTrigger.RepeatInterval = 90; // every ninety days

            DateTimeOffset targetCalendar = new DateTimeOffset(2005, 6, 1, 9, 30, 17, TimeSpan.Zero);

            targetCalendar = targetCalendar.AddDays(360); // jump 360 days (4 intervals)

            IList<DateTimeOffset> fireTimes = TriggerUtils.ComputeFireTimes(dailyTrigger, null, 6);
            DateTimeOffset fifthTime = fireTimes[4]; // get the fifth fire time

            Assert.AreEqual(targetCalendar, fifthTime, "Day increment result not as expected.");
        }
Example #24
0
        public void TestAnnualCalendarTimeZone()
        {
            TimeZoneInfo tz = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
            AnnualCalendar c = new AnnualCalendar();
            c.TimeZone = tz;

            DateTimeOffset excludedDay = new DateTimeOffset(2012, 11, 4, 0, 0, 0, TimeSpan.Zero);
            c.SetDayExcluded(excludedDay, true);

            // 11/5/2012 12:00:00 AM -04:00  translate into 11/4/2012 11:00:00 PM -05:00 (EST)
            DateTimeOffset date = new DateTimeOffset(2012, 11, 5, 0, 0, 0, TimeSpan.FromHours(-4));

            Assert.IsFalse(c.IsTimeIncluded(date), "date was expected to not be included.");
            Assert.IsTrue(c.IsTimeIncluded(date.AddDays(1)));

            DateTimeOffset expectedNextAvailable = new DateTimeOffset(2012, 11, 5, 0, 0, 0, TimeSpan.FromHours(-5));
            DateTimeOffset actualNextAvailable = c.GetNextIncludedTimeUtc(date);
            Assert.AreEqual(expectedNextAvailable, actualNextAvailable);
        }
        public async Task WhenPassingASerializer_ShouldExpandToJson()
        {
            try
            {
                await new HttpClient().GetStringAsync("http://i.do.not.exist");
            }
            catch (Exception e)
            {
                var timestamp = new DateTimeOffset(2013, 05, 28, 22, 10, 20, 666, TimeSpan.FromHours(10));
                var messageTemplate = "{Song}++";
                var template = new MessageTemplateParser().Parse(messageTemplate);
                _options.Serializer = new ElasticsearchJsonNetSerializer();
                using (var sink = new ElasticsearchSink(_options))
                {
                    var properties = new List<LogEventProperty>
                    {
                        new LogEventProperty("Song", new ScalarValue("New Macabre")), 
                        new LogEventProperty("Complex", new ScalarValue(new { A  = 1, B = 2}))
                    };
                    var logEvent = new LogEvent(timestamp, LogEventLevel.Information, null, template, properties);
                    sink.Emit(logEvent);
                    logEvent = new LogEvent(timestamp.AddDays(2), LogEventLevel.Information, e, template, properties);
                    sink.Emit(logEvent);
                }

                _seenHttpPosts.Should().NotBeEmpty().And.HaveCount(1);
                var json = _seenHttpPosts.First();
                var bulkJsonPieces = json.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
                bulkJsonPieces.Should().HaveCount(4);
                bulkJsonPieces[0].Should().Contain(@"""_index"":""logstash-2013.05.28");
                bulkJsonPieces[1].Should().Contain("New Macabre");
                bulkJsonPieces[1].Should().NotContain("Properties\"");
                bulkJsonPieces[2].Should().Contain(@"""_index"":""logstash-2013.05.30");

                //since we pass a serializer objects should serialize as json object and not using their
                //tostring implemenation
                //DO NOTE that you cant send objects as scalar values through Logger.*("{Scalar}", {});
                bulkJsonPieces[3].Should().Contain("Complex\":{");
                bulkJsonPieces[3].Should().Contain("exceptions\":[{");
            }
        }
        public async Task WhenPassingASerializer_ShouldExpandToJson()
        {
            try
            {
                await this.ThrowAsync();
            }
            catch (Exception e)
            {
                var timestamp = new DateTimeOffset(2013, 05, 28, 22, 10, 20, 666, TimeSpan.FromHours(10));
                var messageTemplate = "{Song}++";
                var template = new MessageTemplateParser().Parse(messageTemplate);
                using (var sink = new ElasticsearchSink(_options))
                {
                    var properties = new List<LogEventProperty>
                    {
                        new LogEventProperty("Song", new ScalarValue("New Macabre")), 
                        new LogEventProperty("Complex", new ScalarValue(new { A  = 1, B = 2}))
                    };
                    var logEvent = new LogEvent(timestamp, LogEventLevel.Information, null, template, properties);
                    //one off
                    sink.Emit(logEvent);

                    sink.Emit(logEvent);
                    logEvent = new LogEvent(timestamp.AddDays(2), LogEventLevel.Information, e, template, properties);
                    sink.Emit(logEvent);
                }
                var bulkJsonPieces = this.AssertSeenHttpPosts(_seenHttpPosts, 4);
                bulkJsonPieces[0].Should().Contain(@"""_index"":""logstash-2013.05.28");
                bulkJsonPieces[1].Should().Contain("New Macabre");
                bulkJsonPieces[1].Should().NotContain("Properties\"");
                bulkJsonPieces[2].Should().Contain(@"""_index"":""logstash-2013.05.30");

                //since we pass a serializer objects should serialize as json object and not using their
                //tostring implemenation
                //DO NOTE that you cant send objects as scalar values through Logger.*("{Scalar}", {});
                bulkJsonPieces[3].Should().Contain("Complex\":{");
                bulkJsonPieces[3].Should().Contain("exceptions\":[{");
            }
        }
        public void TestDaylightSavingsTransitions()
        {
            // Pick a day before a daylight savings transition...

            DateTimeOffset startCalendar = DateBuilder.DateOf(9, 30, 17, 12, 3, 2010);

            var dailyTrigger = new CalendarIntervalTriggerImpl
                                                           {
                                                               StartTimeUtc = startCalendar,
                                                               RepeatIntervalUnit = IntervalUnit.Day,
                                                               RepeatInterval = 5   // every 5 days
                                                           };

            DateTimeOffset targetCalendar = startCalendar.AddDays(10); // jump 10 days (2 intervals)

            IList<DateTimeOffset> fireTimes = TriggerUtils.ComputeFireTimes(dailyTrigger, null, 6);
            DateTimeOffset testTime = fireTimes[2]; // get the third fire time

            Assert.AreEqual(targetCalendar, testTime, "Day increment result not as expected over spring daylight savings transition.");

            // Pick a day before a daylight savings transition...

            startCalendar = new DateTimeOffset(2010, 10, 31, 9, 30, 17, TimeSpan.Zero);

            dailyTrigger = new CalendarIntervalTriggerImpl
                               {
                                   StartTimeUtc = startCalendar,
                                   RepeatIntervalUnit = IntervalUnit.Day,
                                   RepeatInterval = 5   // every 5 days
                               };

            targetCalendar = startCalendar.AddDays(15); // jump 15 days (3 intervals)

            fireTimes = TriggerUtils.ComputeFireTimes(dailyTrigger, null, 6);
            testTime = fireTimes[3]; // get the fourth fire time

            Assert.AreEqual(targetCalendar, testTime, "Day increment result not as expected over fall daylight savings transition.");
        }
Example #28
0
 private static DateTimeOffset? GetNextTransition(TimeZoneInfo zone, DateTimeOffset start, DateTimeOffset end)
 {
     TimeSpan startOffset = zone.GetUtcOffset(start);
     bool startDaylight = zone.IsDaylightSavingTime(start);
     DateTimeOffset now = start.AddDays(1);
     while (now <= end)
     {
         if (zone.GetUtcOffset(now) != startOffset || zone.IsDaylightSavingTime(now) != startDaylight)
         {
             // Right, so there's a transition strictly after now - (one day), and less than or equal to now. Binary search...
             long upperInclusiveTicks = now.Ticks;
             long lowerExclusiveTicks = now.AddDays(-1).Ticks;
             while (upperInclusiveTicks > lowerExclusiveTicks + 1)
             {
                 long candidateTicks = (upperInclusiveTicks + lowerExclusiveTicks) / 2;
                 var candidateDto = new DateTimeOffset(candidateTicks, TimeSpan.Zero);
                 if (zone.GetUtcOffset(candidateDto) != startOffset || zone.IsDaylightSavingTime(candidateDto) != startDaylight)
                 {
                     // Still seeing a difference: look earlier
                     upperInclusiveTicks = candidateTicks;
                 }
                 else
                 {
                     // Same as at start of day: look later
                     lowerExclusiveTicks = candidateTicks;
                 }
             }
             // If we turn out to have hit the end point, we're done without a final transition.
             return upperInclusiveTicks == end.Ticks
                 ? (DateTimeOffset?)null
                 : new DateTimeOffset(upperInclusiveTicks, TimeSpan.Zero);
         }
         now = now.AddDays(1);
     }
     return null;
 }
        public static DateTimeOffset GetNextWeekday(this DateTimeOffset start, DayOfWeek day)
        {
            var daysToAdd = ((int)day - (int)start.DayOfWeek + 7) % 7;

            return(start.AddDays(daysToAdd));
        }
        public static void runOneCustCreatedDateIdxRead(Resources context, string filePath, TestType testType, TestWorkload testWorkload, string CustAccount, DateTimeOffset CreatedDateTime, string DataAreaId)
        {
            Stopwatch sw = new Stopwatch();

            sw.Start();

            SalesOrderHeaderV2 SalesOrderHeaderV2 = context.SalesOrderHeadersV2.Where(x => x.OrderingCustomerAccountNumber == CustAccount)
                                                    .Where(x => x.OrderCreationDateTime >= CreatedDateTime.AddDays(-1))
                                                    .Where(x => x.dataAreaId == DataAreaId).First();

            sw.Stop();

            StreamWriter stream = File.AppendText(filePath);

            stream.WriteLine(Entity + "," + testType + "," + testWorkload + "," + sw.Elapsed.TotalMilliseconds.ToString());
            stream.Flush();
            stream.Close();
        }
        /// <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;
                }
            }
        }
Example #32
0
        /// <summary>
        /// Get a <see cref="DateTimeOffset" /> object that represents the given time, on
        /// tomorrow's date.
        /// </summary>
        /// <param name="hour"></param>
        /// <param name="minute"></param>
        /// <param name="second"></param>
        /// <returns></returns>
        public static DateTimeOffset TomorrowAt(int hour, int minute, int second)
        {
            ValidateSecond(second);
            ValidateMinute(minute);
            ValidateHour(hour);

            DateTimeOffset now = DateTimeOffset.Now;
            DateTimeOffset c = new DateTimeOffset(
                now.Year,
                now.Month,
                now.Day,
                hour,
                minute,
                second,
                0,
                now.Offset);

            // advance one day
            c = c.AddDays(1);

            return c;
        }
Example #33
0
        public static void AssociatePersistedKey_CAPIviaCNG_DSA(int provType)
        {
            const string KeyName = nameof(AssociatePersistedKey_CAPIviaCNG_DSA);

            CspParameters cspParameters = new CspParameters(provType)
            {
                KeyContainerName = KeyName,
                Flags            = CspProviderFlags.UseNonExportableKey,
            };

            using (DSACryptoServiceProvider dsaCsp = new DSACryptoServiceProvider(cspParameters))
            {
                dsaCsp.PersistKeyInCsp = false;

                X509SignatureGenerator dsaGen = new DSAX509SignatureGenerator(dsaCsp);

                // Use SHA-1 because that's all DSACryptoServiceProvider understands.
                HashAlgorithmName hashAlgorithm = HashAlgorithmName.SHA1;
                byte[]            signature;

                CertificateRequest request = new CertificateRequest(
                    new X500DistinguishedName($"CN={KeyName}-{provType}"),
                    dsaGen.PublicKey,
                    hashAlgorithm);

                DateTimeOffset now = DateTimeOffset.UtcNow;

                using (X509Certificate2 cert = request.Create(request.SubjectName, dsaGen, now, now.AddDays(1), new byte[1]))
                    using (X509Certificate2 certWithPrivateKey = cert.CopyWithPrivateKey(dsaCsp))
                        using (DSA dsa = certWithPrivateKey.GetDSAPrivateKey())
                        {
                            // `dsa` will be an DSACng wrapping the CAPI key
                            Assert.IsAssignableFrom <DSACng>(dsa);

                            request = new CertificateRequest(
                                new X500DistinguishedName($"CN={KeyName}-{provType}-again"),
                                dsaGen.PublicKey,
                                hashAlgorithm);

                            using (X509Certificate2 cert2 = request.Create(request.SubjectName, dsaGen, now, now.AddDays(1), new byte[1]))
                                using (X509Certificate2 cert2WithPrivateKey = cert2.CopyWithPrivateKey(dsa))
                                    using (DSA dsa2 = cert2WithPrivateKey.GetDSAPrivateKey())
                                    {
                                        signature = dsa2.SignData(Array.Empty <byte>(), hashAlgorithm);

                                        Assert.True(dsaCsp.VerifyData(Array.Empty <byte>(), signature, hashAlgorithm));
                                    }
                        }

                // Some certs have disposed, did they delete the key?
                cspParameters.Flags = CspProviderFlags.UseExistingKey;

                using (var stillPersistedKey = new DSACryptoServiceProvider(cspParameters))
                {
                    stillPersistedKey.SignData(Array.Empty <byte>(), hashAlgorithm);
                }
            }
        }
Example #34
0
        public static void AssociatePersistedKey_CNG_DSA()
        {
            const string KeyName = nameof(AssociatePersistedKey_CNG_DSA);

            CngKey            cngKey        = null;
            HashAlgorithmName hashAlgorithm = HashAlgorithmName.SHA256;

            byte[] signature;

            try
            {
                CngKeyCreationParameters creationParameters = new CngKeyCreationParameters()
                {
                    ExportPolicy       = CngExportPolicies.None,
                    Provider           = CngProvider.MicrosoftSoftwareKeyStorageProvider,
                    KeyCreationOptions = CngKeyCreationOptions.OverwriteExistingKey,
                    Parameters         =
                    {
                        new CngProperty("Length", BitConverter.GetBytes(1024), CngPropertyOptions.None),
                    }
                };

                cngKey = CngKey.Create(new CngAlgorithm("DSA"), KeyName, creationParameters);

                using (DSACng dsaCng = new DSACng(cngKey))
                {
                    X509SignatureGenerator dsaGen = new DSAX509SignatureGenerator(dsaCng);

                    CertificateRequest request = new CertificateRequest(
                        new X500DistinguishedName($"CN={KeyName}"),
                        dsaGen.PublicKey,
                        HashAlgorithmName.SHA256);

                    DateTimeOffset now = DateTimeOffset.UtcNow;

                    using (X509Certificate2 cert = request.Create(request.SubjectName, dsaGen, now, now.AddDays(1), new byte[1]))
                        using (X509Certificate2 certWithPrivateKey = cert.CopyWithPrivateKey(dsaCng))
                            using (DSA dsa = certWithPrivateKey.GetDSAPrivateKey())
                            {
                                signature = dsa.SignData(Array.Empty <byte>(), hashAlgorithm);

                                Assert.True(dsaCng.VerifyData(Array.Empty <byte>(), signature, hashAlgorithm));
                            }
                }

                // Some certs have disposed, did they delete the key?
                using (CngKey stillPersistedKey = CngKey.Open(KeyName, CngProvider.MicrosoftSoftwareKeyStorageProvider))
                    using (DSACng dsaCng = new DSACng(stillPersistedKey))
                    {
                        dsaCng.SignData(Array.Empty <byte>(), hashAlgorithm);
                    }
            }
            finally
            {
                cngKey?.Delete();
            }
        }
Example #35
0
        public static void ThirdPartyProvider_DSA()
        {
            using (DSA dsaOther = new DSAOther())
            {
                dsaOther.ImportParameters(TestData.GetDSA1024Params());

                X509SignatureGenerator dsaGen = new DSAX509SignatureGenerator(dsaOther);

                // macOS DSA is limited to FIPS 186-3.
                HashAlgorithmName hashAlgorithm = HashAlgorithmName.SHA1;

                CertificateRequest request = new CertificateRequest(
                    new X500DistinguishedName($"CN={nameof(ThirdPartyProvider_DSA)}"),
                    dsaGen.PublicKey,
                    hashAlgorithm);

                byte[] signature;
                byte[] data = request.SubjectName.RawData;

                DateTimeOffset now = DateTimeOffset.UtcNow;

                using (X509Certificate2 cert = request.Create(request.SubjectName, dsaGen, now, now.AddDays(1), new byte[1]))
                    using (X509Certificate2 certWithPrivateKey = cert.CopyWithPrivateKey(dsaOther))
                        using (DSA dsa = certWithPrivateKey.GetDSAPrivateKey())
                        {
                            signature = dsa.SignData(data, hashAlgorithm);
                        }

                Assert.True(dsaOther.VerifyData(data, signature, hashAlgorithm));
            }
        }
Example #36
0
        /// <summary>
        /// Checks if all slots for the day, and testing place has been created
        /// </summary>
        /// <returns></returns>
        public async Task <int> CheckSlots(long testingDay, string placeId, string openingHours = "09:00-20:00", int openingHoursTemplate = 0)
        {
            int ret  = 0;
            var day  = new DateTimeOffset(testingDay, TimeSpan.Zero);
            var list = await ListDaySlotsByPlace(placeId);

            if (string.IsNullOrEmpty(openingHours))
            {
                //delete place
                var dayslot = list.FirstOrDefault(d => d.Time.Ticks == testingDay);
                if (dayslot != null)
                {
                    await DeleteDaySlot(dayslot);
                }
            }
            else
            {
                if (!list.Any(d => d.Time.Ticks == testingDay))
                {
                    ret++;
                    var result = await Add(new Slot1Day()
                    {
                        PlaceId              = placeId,
                        Registrations        = 0,
                        Time                 = day,
                        OpeningHours         = openingHours,
                        OpeningHoursTemplate = openingHoursTemplate,

                        Description = (day + TimeZoneInfo.Local.GetUtcOffset(day)).ToString("dd.MM.yyyy", CultureInfo.CurrentCulture)
                    });

                    if (!result)
                    {
                        throw new Exception(localizer[Repository_RedisRepository_SlotRepository.Error_adding_the_slot_for_day].Value);
                    }
                }
                else
                {
                }
            }

            var start    = day;
            var end      = day.AddDays(1);
            var iterator = TimeSpan.Zero;

            var listH       = (await ListHourSlotsByPlaceAndDaySlotId(placeId, testingDay)).ToDictionary(t => t.Time.Ticks, t => t);
            var hoursParsed = openingHours.ParseOpeningHours();
            var t           = start + iterator;

            while (t < end)
            {
                var tNext = t.AddHours(1);


                if (hoursParsed.HasAnySlotWithinHourOpen(iterator))
                {
                    if (!listH.ContainsKey(t.Ticks))
                    {
                        ret++;
                        await Add(new Slot1Hour()
                        {
                            PlaceId       = placeId,
                            Registrations = 0,
                            Time          = t,
                            DaySlotId     = day.Ticks,
                            TestingDayId  = testingDay,
                            Description   = $"{(t).ToString("HH:mm", CultureInfo.CurrentCulture)} - {(tNext).ToString("HH:mm", CultureInfo.CurrentCulture)}"
                        });
                    }
                }
                else
                {
                    // remove slot
                    if (listH.ContainsKey(t.Ticks))
                    {
                        ret++;
                        await DeleteHourSlot(listH[t.Ticks]);
                    }
                }

                iterator = iterator.Add(TimeSpan.FromHours(1));
                t        = start + iterator;
            }

            iterator = TimeSpan.Zero;
            var tMin = start + iterator;

            t = tMin;
            var tMinNext = tMin.AddMinutes(5);
            var listM    = (await ListMinuteSlotsByPlaceAndHourSlotId(placeId, t.Ticks)).ToDictionary(t => t.Time.Ticks, t => t);
            var lastH    = tMin.Hour;

            while (tMin < end)
            {
                tMinNext = tMin.AddMinutes(5);

                if (lastH != tMin.Hour)
                {
                    listM = (await ListMinuteSlotsByPlaceAndHourSlotId(placeId, tMin.Ticks)).ToDictionary(t => t.Time.Ticks, t => t);
                    t     = tMin;
                    lastH = tMin.Hour;
                }

                if (hoursParsed.IsTimeWhenIsOpen(iterator))
                {
                    if (!listM.ContainsKey(tMin.Ticks))
                    {
                        ret++;
                        await Add(new Slot5Min()
                        {
                            PlaceId       = placeId,
                            Registrations = 0,
                            Time          = tMin,
                            TestingDayId  = testingDay,
                            HourSlotId    = t.Ticks,
                            Description   = $"{(tMin).ToString("HH:mm", CultureInfo.CurrentCulture)} - {(tMinNext).ToString("HH:mm", CultureInfo.CurrentCulture)}"
                        });
                    }
                }
                else
                {
                    // remove slot
                    if (listM.ContainsKey(tMin.Ticks))
                    {
                        ret++;
                        await DeleteMinuteSlot(listM[tMin.Ticks]);
                    }
                }

                iterator = iterator.Add(TimeSpan.FromMinutes(5));
                tMin     = start + iterator;
            }

            return(ret);
        }
Example #37
0
 public static DateTimeOffset NextTimeOfDay(this DateTimeOffset dateTime, TimeSpan timeOfDay) =>
 dateTime.TimeOfDay <= timeOfDay
         ? dateTime.AtTimeOfDay(timeOfDay)
         : dateTime.AddDays(1).AtTimeOfDay(timeOfDay);
Example #38
0
        public void BuildReport_WithMultipleRatesAndPlayersWithDifferentMembershipDurations_CalculatesCorrectAmountDueForEachPlayer()
        {
            var firstRateStart = new DateTimeOffset(2020, 06, 24, 0, 0, 0, TimeSpan.FromHours(1));
            var tariff         = new Tariff
            {
                History = new []
                {
                    new TariffItem
                    {
                        Amount         = CurrencyAmount.FromGold(40),
                        BeginsOn       = firstRateStart,
                        RepeatInterval = TimeSpan.FromDays(7)
                    },
                    new TariffItem
                    {
                        Amount         = CurrencyAmount.FromGold(20),
                        BeginsOn       = firstRateStart.AddDays(21),
                        RepeatInterval = TimeSpan.FromDays(7)
                    },
                }
            };

            var roster = new Roster()
                         .Add(new Player("Neffer"))
                         .Add(new Player("Demusske")
            {
                JoinedOn = firstRateStart.AddDays(7)
            })
                         .Add(new Player("Dizzay")
            {
                LeftOn = firstRateStart.AddDays(28)
            })
                         .Add(new Player("Unboned")
            {
                LeftOn = firstRateStart.AddDays(-5)
            });

            // 3 weeks of 40g, 5 weeks of 20g
            var            now = firstRateStart.AddDays(7 * 8);
            CurrencyAmount nefferExpectedDue   = CurrencyAmount.FromGold(220);
            CurrencyAmount demusskeExpectedDue = CurrencyAmount.FromGold(180);
            CurrencyAmount dizzayExpectedDue   = CurrencyAmount.FromGold(140);
            CurrencyAmount unbonedExpectedDue  = CurrencyAmount.FromGold(0);

            A.CallTo(() => _dataSource.GetRoster()).Returns(roster);
            A.CallTo(() => _dataSource.GetTariff()).Returns(tariff);
            A.CallTo(() => _dataSource.NowServerTime).Returns(now);

            var sut = CreateSut();

            sut.BuildReport();

            var neffer   = sut.PlayerReports.Single(pr => pr.Player.Main.Name == "Neffer");
            var demusske = sut.PlayerReports.Single(pr => pr.Player.Main.Name == "Demusske");
            var dizzay   = sut.PlayerReports.Single(pr => pr.Player.Main.Name == "Dizzay");
            var unboned  = sut.PlayerReports.Single(pr => pr.Player.Main.Name == "Unboned");

            neffer.AmountDueToDate.Should().Be(nefferExpectedDue);
            demusske.AmountDueToDate.Should().Be(demusskeExpectedDue);
            dizzay.AmountDueToDate.Should().Be(dizzayExpectedDue);
            unboned.AmountDueToDate.Should().Be(unbonedExpectedDue);
        }
        public static void UniqueExtensions()
        {
            using (RSA rsa = RSA.Create())
            {
                CertificateRequest request = new CertificateRequest(
                    "CN=Double Extension Test",
                    rsa,
                    HashAlgorithmName.SHA256,
                    RSASignaturePadding.Pkcs1);

                request.CertificateExtensions.Add(
                    new X509BasicConstraintsExtension(true, false, 0, true));

                request.CertificateExtensions.Add(
                    new X509BasicConstraintsExtension(true, false, 0, true));

                DateTimeOffset now = DateTimeOffset.UtcNow;

                Assert.Throws <InvalidOperationException>(() => request.CreateSelfSigned(now, now.AddDays(1)));
            }
        }
        public void Can_insert_datetimeoffsets_regardless_of_current_culture()
        {
            // datetimeoffset's default .ToString depends on culture, ensure we use one with MDY
            var previousCulture = System.Threading.Thread.CurrentThread.CurrentCulture;
            System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
            try
            {
                using (var db = OpenDbConnection())
                {
                    // and set datestyle to DMY, crashing the insert when we're formatting it as the default on en-US
                    db.ExecuteNonQuery("SET datestyle TO \"ISO, DMY\"");
                    db.CreateTable<ModelWithDateTimeOffset>(true);

                    var date = new DateTimeOffset(2010, 11, 29, 1, 2, 3, new TimeSpan(0));
                    var row = new ModelWithDateTimeOffset
                    {
                        Id = 1,
                        Value = date
                    };

                    db.Insert(row);
                    db.Update<ModelWithDateTimeOffset>(new { Value = date.AddDays(30) }, r => r.Id == 1);

                    var rows = db.Select<ModelWithDateTimeOffset>();

                    Assert.That(rows, Has.Count.EqualTo(1));
                    Assert.That(rows[0].Value, Is.EqualTo(date.AddDays(30)));
                }
            }
            finally
            {
                System.Threading.Thread.CurrentThread.CurrentCulture = previousCulture;
            }
        }
Example #41
0
        protected DateTimeOffset?GetFireTimeAfter(DateTimeOffset?afterTime, bool ignoreEndTime)
        {
            if (complete)
            {
                return(null);
            }

            // increment afterTime by a second, so that we are
            // comparing against a time after it!
            if (afterTime == null)
            {
                afterTime = SystemTime.UtcNow().AddSeconds(1);
            }
            else
            {
                afterTime = afterTime.Value.AddSeconds(1);
            }

            DateTimeOffset startMillis = StartTimeUtc;
            DateTimeOffset afterMillis = afterTime.Value;
            DateTimeOffset endMillis   = (EndTimeUtc == null) ? DateTimeOffset.MaxValue : EndTimeUtc.Value;

            if (!ignoreEndTime && (endMillis <= afterMillis))
            {
                return(null);
            }

            if (afterMillis < startMillis)
            {
                return(startMillis);
            }

            long secondsAfterStart = (long)(afterMillis - startMillis).TotalSeconds;

            DateTimeOffset?time       = null;
            long           repeatLong = RepeatInterval;

            DateTimeOffset sTime = StartTimeUtc;

            if (timeZone != null)
            {
                sTime = TimeZoneUtil.ConvertTime(sTime, timeZone);
            }

            if (RepeatIntervalUnit == IntervalUnit.Second)
            {
                long jumpCount = secondsAfterStart / repeatLong;
                if (secondsAfterStart % repeatLong != 0)
                {
                    jumpCount++;
                }
                time = sTime.AddSeconds(RepeatInterval * (int)jumpCount);
            }
            else if (RepeatIntervalUnit == IntervalUnit.Minute)
            {
                long jumpCount = secondsAfterStart / (repeatLong * 60L);
                if (secondsAfterStart % (repeatLong * 60L) != 0)
                {
                    jumpCount++;
                }
                time = sTime.AddMinutes(RepeatInterval * (int)jumpCount);
            }
            else if (RepeatIntervalUnit == IntervalUnit.Hour)
            {
                long jumpCount = secondsAfterStart / (repeatLong * 60L * 60L);
                if (secondsAfterStart % (repeatLong * 60L * 60L) != 0)
                {
                    jumpCount++;
                }
                time = sTime.AddHours(RepeatInterval * (int)jumpCount);
            }
            else
            {
                // intervals a day or greater ...

                int initialHourOfDay = sTime.Hour;

                if (RepeatIntervalUnit == IntervalUnit.Day)
                {
                    // Because intervals greater than an hour have an non-fixed number
                    // of seconds in them (due to daylight savings, variation number of
                    // days in each month, leap year, etc. ) we can't jump forward an
                    // exact number of seconds to calculate the fire time as we can
                    // with the second, minute and hour intervals.   But, rather
                    // than slowly crawling our way there by iteratively adding the
                    // increment to the start time until we reach the "after time",
                    // we can first make a big leap most of the way there...

                    long jumpCount = secondsAfterStart / (repeatLong * 24L * 60L * 60L);
                    // if we need to make a big jump, jump most of the way there,
                    // but not all the way because in some cases we may over-shoot or under-shoot
                    if (jumpCount > 20)
                    {
                        if (jumpCount < 50)
                        {
                            jumpCount = (long)(jumpCount * 0.80);
                        }
                        else if (jumpCount < 500)
                        {
                            jumpCount = (long)(jumpCount * 0.90);
                        }
                        else
                        {
                            jumpCount = (long)(jumpCount * 0.95);
                        }
                        sTime = sTime.AddDays(RepeatInterval * jumpCount);
                    }

                    // now baby-step the rest of the way there...
                    while (sTime.UtcDateTime < afterTime.Value.UtcDateTime && sTime.Year < YearToGiveupSchedulingAt)
                    {
                        sTime = sTime.AddDays(RepeatInterval);
                        MakeHourAdjustmentIfNeeded(ref sTime, initialHourOfDay); //hours can shift due to DST
                    }
                    while (DaylightSavingHourShiftOccuredAndAdvanceNeeded(ref sTime, initialHourOfDay) && sTime.Year < YearToGiveupSchedulingAt)
                    {
                        sTime = sTime.AddDays(RepeatInterval);
                    }

                    time = sTime;
                }
                else if (RepeatIntervalUnit == IntervalUnit.Week)
                {
                    // Because intervals greater than an hour have an non-fixed number
                    // of seconds in them (due to daylight savings, variation number of
                    // days in each month, leap year, etc. ) we can't jump forward an
                    // exact number of seconds to calculate the fire time as we can
                    // with the second, minute and hour intervals.   But, rather
                    // than slowly crawling our way there by iteratively adding the
                    // increment to the start time until we reach the "after time",
                    // we can first make a big leap most of the way there...

                    long jumpCount = secondsAfterStart / (repeatLong * 7L * 24L * 60L * 60L);
                    // if we need to make a big jump, jump most of the way there,
                    // but not all the way because in some cases we may over-shoot or under-shoot
                    if (jumpCount > 20)
                    {
                        if (jumpCount < 50)
                        {
                            jumpCount = (long)(jumpCount * 0.80);
                        }
                        else if (jumpCount < 500)
                        {
                            jumpCount = (long)(jumpCount * 0.90);
                        }
                        else
                        {
                            jumpCount = (long)(jumpCount * 0.95);
                        }
                        sTime = sTime.AddDays((int)(RepeatInterval * jumpCount * 7));
                    }

                    while (sTime.UtcDateTime < afterTime.Value.UtcDateTime && sTime.Year < YearToGiveupSchedulingAt)
                    {
                        sTime = sTime.AddDays(RepeatInterval * 7);
                        MakeHourAdjustmentIfNeeded(ref sTime, initialHourOfDay); //hours can shift due to DST
                    }
                    while (DaylightSavingHourShiftOccuredAndAdvanceNeeded(ref sTime, initialHourOfDay) && sTime.Year < YearToGiveupSchedulingAt)
                    {
                        sTime = sTime.AddDays(RepeatInterval * 7);
                    }
                    time = sTime;
                }
                else if (RepeatIntervalUnit == IntervalUnit.Month)
                {
                    // because of the large variation in size of months, and
                    // because months are already large blocks of time, we will
                    // just advance via brute-force iteration.

                    while (sTime.UtcDateTime < afterTime.Value.UtcDateTime && sTime.Year < YearToGiveupSchedulingAt)
                    {
                        sTime = sTime.AddMonths(RepeatInterval);
                        MakeHourAdjustmentIfNeeded(ref sTime, initialHourOfDay); //hours can shift due to DST
                    }
                    while (DaylightSavingHourShiftOccuredAndAdvanceNeeded(ref sTime, initialHourOfDay) &&
                           sTime.Year < YearToGiveupSchedulingAt)
                    {
                        sTime = sTime.AddMonths(RepeatInterval);
                    }
                    time = sTime;
                }
                else if (RepeatIntervalUnit == IntervalUnit.Year)
                {
                    while (sTime.UtcDateTime < afterTime.Value.UtcDateTime && sTime.Year < YearToGiveupSchedulingAt)
                    {
                        sTime = sTime.AddYears(RepeatInterval);
                        MakeHourAdjustmentIfNeeded(ref sTime, initialHourOfDay); //hours can shift due to DST
                    }
                    while (DaylightSavingHourShiftOccuredAndAdvanceNeeded(ref sTime, initialHourOfDay) && sTime.Year < YearToGiveupSchedulingAt)
                    {
                        sTime = sTime.AddYears(RepeatInterval);
                    }
                    time = sTime;
                }
            } // case of interval of a day or greater
            if (!ignoreEndTime && endMillis <= time)
            {
                return(null);
            }

            sTime = TimeZoneUtil.ConvertTime(sTime, this.TimeZone); //apply the timezone before we return the time.
            return(time);
        }
Example #42
0
        static QueryCompiler()
        {
            forType(count =>
            {
                var values = new string[count];
                for (int i = 0; i < values.Length; i++)
                {
                    values[i] = Guid.NewGuid().ToString();
                }

                return(values);
            });

            forType(count =>
            {
                var values = new Guid[count];
                for (int i = 0; i < values.Length; i++)
                {
                    values[i] = Guid.NewGuid();
                }

                return(values);
            });

            forType(count =>
            {
                var value  = -100000;
                var values = new int[count];
                for (int i = 0; i < values.Length; i++)
                {
                    values[i] = value--;
                }

                return(values);
            });

            forType(count =>
            {
                var value  = -200000L;
                var values = new long[count];
                for (int i = 0; i < values.Length; i++)
                {
                    values[i] = value--;
                }

                return(values);
            });

            forType(count =>
            {
                var value  = -300000L;
                var values = new float[count];
                for (int i = 0; i < values.Length; i++)
                {
                    values[i] = value--;
                }

                return(values);
            });

            forType(count =>
            {
                var value  = -300000L;
                var values = new decimal[count];
                for (int i = 0; i < values.Length; i++)
                {
                    values[i] = value--;
                }

                return(values);
            });

            forType(count =>
            {
                var value  = new DateTime(1600, 1, 1);
                var values = new DateTime[count];
                for (int i = 0; i < values.Length; i++)
                {
                    values[i] = value.AddDays(-1);
                }

                return(values);
            });

            forType(count =>
            {
                var value  = new DateTimeOffset(1600, 1, 1, 0, 0, 0, 0.Seconds());
                var values = new DateTimeOffset[count];
                for (int i = 0; i < values.Length; i++)
                {
                    values[i] = value.AddDays(-1);
                }

                return(values);
            });
        }
Example #43
0
        public static void AssociatePersistedKey_CAPIviaCNG_RSA(int provType, KeyNumber keyNumber)
        {
            const string KeyName = nameof(AssociatePersistedKey_CAPIviaCNG_RSA);

            CspParameters cspParameters = new CspParameters(provType)
            {
                KeyNumber        = (int)keyNumber,
                KeyContainerName = KeyName,
                Flags            = CspProviderFlags.UseNonExportableKey,
            };

            using (RSACryptoServiceProvider rsaCsp = new RSACryptoServiceProvider(cspParameters))
            {
                rsaCsp.PersistKeyInCsp = false;

                // Use SHA-1 because the FULL and SCHANNEL providers can't handle SHA-2.
                HashAlgorithmName hashAlgorithm = HashAlgorithmName.SHA1;
                var    generator = new RSASha1Pkcs1SignatureGenerator(rsaCsp);
                byte[] signature;

                CertificateRequest request = new CertificateRequest(
                    $"CN={KeyName}-{provType}-{keyNumber}",
                    rsaCsp,
                    hashAlgorithm);

                DateTimeOffset now = DateTimeOffset.UtcNow;

                using (X509Certificate2 cert = request.Create(request.SubjectName, generator, now, now.AddDays(1), new byte[1]))
                    using (X509Certificate2 withPrivateKey = cert.CopyWithPrivateKey(rsaCsp))
                        using (RSA rsa = withPrivateKey.GetRSAPrivateKey())
                        {
                            // `rsa` will be an RSACng wrapping the CAPI key, which means it does not expose the
                            // KeyNumber from CAPI.
                            Assert.IsAssignableFrom <RSACng>(rsa);

                            request = new CertificateRequest(
                                $"CN={KeyName}-{provType}-{keyNumber}-again",
                                rsa,
                                hashAlgorithm);

                            X509Certificate2 cert2 = request.Create(
                                request.SubjectName,
                                generator,
                                now,
                                now.AddDays(1),
                                new byte[1]);

                            using (cert2)
                                using (X509Certificate2 withPrivateKey2 = cert2.CopyWithPrivateKey(rsaCsp))
                                    using (RSA rsa2 = withPrivateKey2.GetRSAPrivateKey())
                                    {
                                        signature = rsa2.SignData(
                                            Array.Empty <byte>(),
                                            hashAlgorithm,
                                            RSASignaturePadding.Pkcs1);

                                        Assert.True(
                                            rsaCsp.VerifyData(
                                                Array.Empty <byte>(),
                                                signature,
                                                hashAlgorithm,
                                                RSASignaturePadding.Pkcs1));
                                    }
                        }

                // Some certs have disposed, did they delete the key?
                cspParameters.Flags = CspProviderFlags.UseExistingKey;

                using (RSACryptoServiceProvider stillPersistedKey = new RSACryptoServiceProvider(cspParameters))
                {
                    byte[] signature2 = stillPersistedKey.SignData(
                        Array.Empty <byte>(),
                        hashAlgorithm,
                        RSASignaturePadding.Pkcs1);

                    Assert.Equal(signature, signature2);
                }
            }
        }
Example #44
0
        // TODO: Put strings into the resources.
        //
        public static void GetDatePeriod(this DateTimeOffset referenceDateTime, DatePeriodKind kind, out DateTimeOffset periodFrom, out DateTimeOffset periodUntil, ArgumentPlaceholder <DayOfWeek> firstDayOfWeek = default)
        {
            if (kind == DatePeriodKind.Any)
            {
                throw new ArgumentOutOfRangeException(nameof(kind));
            }
            //
            DateTimeOffset locPeriodFrom, locPeriodUntil;
            var            locFirstDayOfWeek = firstDayOfWeek.Substitute(value: CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek);
            var            referenceDate     =
                new DateTimeOffset(
                    year: referenceDateTime.Year,
                    month: referenceDateTime.Month,
                    day: referenceDateTime.Day,
                    hour: 0,
                    minute: 0,
                    second: 0,
                    offset: referenceDateTime.Offset);
            var referenceDateUntil = referenceDate.AddDays(1.0D);

            switch (kind)
            {
            case DatePeriodKind.CurrentMonth:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, referenceDate.Month, 1, 0, 0, 0, referenceDate.Offset);
                locPeriodUntil = locPeriodFrom.AddMonths(1);
                break;

            case DatePeriodKind.CurrentDay:
                locPeriodFrom  = referenceDate;
                locPeriodUntil = locPeriodFrom.AddDays(1.0);
                break;

            case DatePeriodKind.CurrentWeek:
                locFirstDayOfWeek = CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek;
                locPeriodFrom     = referenceDate.AddDays(-(NumberOfDayOfWeek(referenceDate.DayOfWeek, locFirstDayOfWeek) - 1));
                locPeriodUntil    = locPeriodFrom.AddDays(7.0);
                break;

            case DatePeriodKind.CurrentQuarter:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, (int)Math.Ceiling(referenceDate.Month / 3.0D) * 3, 1, 0, 0, 0, referenceDate.Offset).AddMonths(-2);
                locPeriodUntil = locPeriodFrom.AddMonths(3);
                break;

            case DatePeriodKind.CurrentHalfOfYear:
                locPeriodFrom  = referenceDate.Month > 6 ? new DateTimeOffset(referenceDate.Year, 7, 1, 0, 0, 0, referenceDate.Offset) : new DateTimeOffset(referenceDate.Year, 1, 1, 0, 0, 0, referenceDate.Offset);
                locPeriodUntil = locPeriodFrom.AddMonths(6);
                break;

            case DatePeriodKind.CurrentYear:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, 1, 1, 0, 0, 0, referenceDate.Offset);
                locPeriodUntil = locPeriodFrom.AddYears(1);
                break;

            case DatePeriodKind.BeginOfMonth:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, referenceDate.Month, 1, 0, 0, 0, referenceDate.Offset);
                locPeriodUntil = referenceDateUntil;
                break;

            case DatePeriodKind.BeginOfWeek:
                locPeriodFrom  = referenceDate.AddDays(-(DateTimeUtilities.NumberOfDayOfWeek(referenceDate.DayOfWeek, locFirstDayOfWeek) - 1));
                locPeriodUntil = referenceDateUntil;
                break;

            case DatePeriodKind.BeginOfQuarter:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, (int)Math.Ceiling(referenceDate.Month / 3.0D) * 3, 1, 0, 0, 0, referenceDate.Offset).AddMonths(-2);
                locPeriodUntil = referenceDate;
                break;

            case DatePeriodKind.BeginOfHalfOfYear:
                locPeriodFrom  = referenceDate.Month > 6 ? new DateTimeOffset(referenceDate.Year, 7, 1, 0, 0, 0, referenceDate.Offset) : new DateTimeOffset(referenceDate.Year, 1, 1, 0, 0, 0, referenceDate.Offset);
                locPeriodUntil = referenceDateUntil;
                break;

            case DatePeriodKind.BeginOfYear:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, 1, 1, 0, 0, 0, referenceDate.Offset);
                locPeriodUntil = referenceDateUntil;
                break;

            case DatePeriodKind.PreviousDay:
                locPeriodFrom  = referenceDate.AddDays(-1);
                locPeriodUntil = referenceDate;
                break;

            case DatePeriodKind.PreviousWeek:
                locPeriodFrom  = referenceDate.AddDays(-(NumberOfDayOfWeek(referenceDate.DayOfWeek, locFirstDayOfWeek) + 6));
                locPeriodUntil = locPeriodFrom.AddDays(7.0);
                break;

            case DatePeriodKind.PreviousMonth:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, referenceDate.Month, 1, 0, 0, 0, 0, referenceDate.Offset).AddMonths(-1);
                locPeriodUntil = locPeriodFrom.AddMonths(1);
                break;

            case DatePeriodKind.PreviousQuarter:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, (int)Math.Ceiling(referenceDate.Month / 3.0D) * 3, 1, 0, 0, 0, referenceDate.Offset).AddMonths(-5);
                locPeriodUntil = locPeriodFrom.AddMonths(3);
                break;

            case DatePeriodKind.PreviousHalfOfYear:
                locPeriodFrom  = referenceDate.Month > 6 ? new DateTimeOffset(referenceDate.Year, 7, 1, 0, 0, 0, referenceDate.Offset).AddMonths(-6) : new DateTimeOffset(referenceDate.Year, 1, 1, 0, 0, 0, referenceDate.Offset).AddMonths(-6);
                locPeriodUntil = locPeriodFrom.AddMonths(6);
                break;

            case DatePeriodKind.PreviousYear:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, 1, 1, 0, 0, 0, referenceDate.Offset).AddYears(-1);
                locPeriodUntil = locPeriodFrom.AddYears(1);
                break;

            case DatePeriodKind.NextDay:
                locPeriodFrom  = referenceDate.AddDays(1);
                locPeriodUntil = locPeriodFrom.AddDays(1);
                break;

            case DatePeriodKind.NextWeek:
                locPeriodFrom  = referenceDate.AddDays(-(NumberOfDayOfWeek(referenceDate.DayOfWeek, locFirstDayOfWeek) - 8));
                locPeriodUntil = locPeriodFrom.AddDays(7.0);
                break;

            case DatePeriodKind.NextMonth:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, referenceDate.Month, 1, 0, 0, 0, 0, referenceDate.Offset).AddMonths(1);
                locPeriodUntil = locPeriodFrom.AddMonths(1);
                break;

            case DatePeriodKind.NextQuarter:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, (int)Math.Ceiling(referenceDate.Month / 3.0D) * 3, 1, 0, 0, 0, referenceDate.Offset).AddMonths(1);
                locPeriodUntil = locPeriodFrom.AddMonths(3);
                break;

            case DatePeriodKind.NextHalfOfYear:
                locPeriodFrom  = referenceDate.Month > 6 ? new DateTimeOffset(referenceDate.Year, 7, 1, 0, 0, 0, referenceDate.Offset).AddMonths(6) : new DateTimeOffset(referenceDate.Year, 1, 1, 0, 0, 0, referenceDate.Offset).AddMonths(6);
                locPeriodUntil = locPeriodFrom.AddMonths(6);
                break;

            case DatePeriodKind.NextYear:
                locPeriodFrom  = new DateTimeOffset(referenceDate.Year, 1, 1, 0, 0, 0, referenceDate.Offset).AddYears(1);
                locPeriodUntil = locPeriodFrom.AddYears(1);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(kind), $"Значение '{kind}' (тип '{kind.GetType().FullName}' не поддерживается).");
            }
            periodFrom  = locPeriodFrom;
            periodUntil = locPeriodUntil;
        }
Example #45
0
        // yes yes, I know it's complicated, but settle down ReSharper
        // ReSharper disable once FunctionComplexityOverflow
        private static bool TryGetGroupEvent(IrGroup group, DateTimeOffset start, SearchMode mode, out DateTimeOffset result)
        {
            var after = mode == SearchMode.After;
            var inc   = after ? 1 : -1; // used for incrementing values up or down depending on the direction we're searching

            var initHour   = after ? 0 : 23;
            var initMinute = after ? 0 : 59;
            var initSecond = after ? 0 : 59;

            // todo: make the length of the search configurable
            for (var d = 0; d < 367; d++)
            {
                DateTimeOffset date;
                int            hour, minute, second;
                if (d == 0)
                {
                    // "after" events must be in the future
                    date = after ? start.AddSeconds(1) : start;

                    hour   = date.Hour;
                    minute = date.Minute;
                    second = date.Second;
                }
                else
                {
                    date = start.AddDays(d * inc);

                    hour   = initHour;
                    minute = initMinute;
                    second = initSecond;
                }

                var year        = date.Year;
                var month       = date.Month;
                var dayOfWeek   = (int)date.DayOfWeek + 1; // DayOfWeek enum is zero-indexed
                var dayOfMonth  = date.Day;
                var daysInMonth = DateTime.DaysInMonth(year, month);

                // check if today is an applicable date
                if (group.HasDates)
                {
                    var applicable = false;
                    foreach (var range in group.Dates)
                    {
                        if (InDateRange(range, year, month, dayOfMonth))
                        {
                            applicable = true;
                            break;
                        }
                    }

                    if (!applicable)
                    {
                        goto CONTINUE_DATE_LOOP;
                    }
                }

                if (group.HasDatesExcluded)
                {
                    foreach (var range in group.DatesExcluded)
                    {
                        if (InDateRange(range, year, month, dayOfMonth))
                        {
                            goto CONTINUE_DATE_LOOP;
                        }
                    }
                }

                // check if date is an applicable day of month
                if (group.HasDaysOfMonth)
                {
                    var applicable = false;
                    foreach (var range in group.DaysOfMonth)
                    {
                        if (InDayOfMonthRange(range, year, month, dayOfMonth))
                        {
                            applicable = true;
                            break;
                        }
                    }

                    if (!applicable)
                    {
                        goto CONTINUE_DATE_LOOP;
                    }
                }

                if (group.HasDaysOfMonthExcluded)
                {
                    foreach (var range in group.DaysOfMonthExcluded)
                    {
                        if (InDayOfMonthRange(range, year, month, dayOfMonth))
                        {
                            goto CONTINUE_DATE_LOOP;
                        }
                    }
                }

                // check if date is an applicable day of week
                if (group.HasDaysOfWeek && !InRule(7, group.DaysOfWeek, dayOfWeek))
                {
                    goto CONTINUE_DATE_LOOP;
                }

                if (group.HasDaysOfWeekExcluded && InRule(7, group.DaysOfWeekExcluded, dayOfWeek))
                {
                    goto CONTINUE_DATE_LOOP;
                }

                // if we've gotten this far, then today is an applicable day, let's keep going with hour checks
                var hourCount = after ? 24 - hour : hour + 1;
                for (; hourCount-- > 0; hour += inc, minute = initMinute, second = initSecond)
                {
                    if (group.HasHours && !InRule(24, group.Hours, hour))
                    {
                        continue;
                    }

                    if (group.HasHoursExcluded && InRule(24, group.HoursExcluded, hour))
                    {
                        continue;
                    }

                    // if we've gotten here, the date and hour are valid. Let's check for minutes
                    var minuteCount = after ? 60 - minute : minute + 1;
                    for (; minuteCount-- > 0; minute += inc, second = initSecond)
                    {
                        if (group.HasMinutes && !InRule(60, group.Minutes, minute))
                        {
                            continue;
                        }

                        if (group.HasMinutesExcluded && InRule(60, group.MinutesExcluded, minute))
                        {
                            continue;
                        }

                        // check for valid seconds
                        var secondCount = after ? 60 - second : second + 1;
                        for (; secondCount-- > 0; second += inc)
                        {
                            if (group.HasSeconds && !InRule(60, group.Seconds, second))
                            {
                                continue;
                            }

                            if (group.HasSecondsExcluded && InRule(60, group.SecondsExcluded, second))
                            {
                                continue;
                            }

                            // we've found our event
                            result = new DateTimeOffset(year, month, dayOfMonth, hour, minute, second, TimeSpan.Zero);
                            return(true);
                        }
                    }
                }

                CONTINUE_DATE_LOOP :;
            }

            // we didn't find an applicable date
            result = default(DateTimeOffset);
            return(false);
        }
        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();
        }
Example #47
0
        public static DateTimeOffset AddYears(this DateTimeOffset date, double years)
        {
            var daysOfYear = 364; // ToDo: check now year days count

            return(date.AddDays(years * daysOfYear));
        }
Example #48
0
 public static DateTimeOffset AddWeeks(this DateTimeOffset date, double weeks)
 {
     return(date.AddDays(weeks * 7));
 }
Example #49
0
        public void BuildReport_RefundsToPlayersWhoHaveLeft_ShouldNotBeOddTransactions()
        {
            var firstRateStart = new DateTimeOffset(2020, 06, 24, 0, 0, 0, TimeSpan.FromHours(1));
            var now            = firstRateStart.AddDays(7);
            var tariff         = new Tariff
            {
                History = new []
                {
                    new TariffItem
                    {
                        Amount         = CurrencyAmount.FromGold(40),
                        BeginsOn       = firstRateStart,
                        RepeatInterval = TimeSpan.FromDays(7)
                    }
                }
            };

            var roster = new Roster()
                         .Add(new Player("Neffer"))
                         .Add(new Player("Gicanu")
            {
                // Left during week 2
                LeftOn = firstRateStart.AddDays(9)
            });

            var refundTxn = new Transaction(
                TransactionType.MoneyTransfer,
                CurrencyAmount.FromGold(40),
                "Frozengold",
                "Gicanu",
                firstRateStart.AddDays(10));

            IReadOnlyList <Transaction> transactions = new []
            {
                // Income week 1
                new Transaction(
                    TransactionType.MoneyTransfer,
                    CurrencyAmount.FromGold(40),
                    "Neffer",
                    "Frozengold",
                    firstRateStart.AddHours(12)),
                new Transaction(
                    TransactionType.MoneyTransfer,
                    CurrencyAmount.FromGold(40),
                    "Gicanu",
                    "Frozengold",
                    firstRateStart.AddHours(12)),
                // Income week 2
                new Transaction(
                    TransactionType.MoneyTransfer,
                    CurrencyAmount.FromGold(40),
                    "Neffer",
                    "Frozengold",
                    firstRateStart.AddDays(8)),
                new Transaction(
                    TransactionType.MoneyTransfer,
                    CurrencyAmount.FromGold(40),
                    "Gicanu",
                    "Frozengold",
                    firstRateStart.AddDays(8)),
                // Refund
                refundTxn,
            };

            A.CallTo(() => _dataSource.GetRoster()).Returns(roster);
            A.CallTo(() => _dataSource.GetTariff()).Returns(tariff);
            A.CallTo(() => _dataSource.NowServerTime).Returns(now);
            A.CallTo(() => _dataSource.GetTransactionHistory()).Returns(transactions);

            var sut = CreateSut();

            sut.BuildReport();

            sut.Received.Should().Be(CurrencyAmount.FromGold(160));
            sut.Refunded.Should().Be(CurrencyAmount.FromGold(40));
            sut.GoldOnHand.Should().Be(CurrencyAmount.FromGold(120));
            sut.OddTransactions.Should().BeEmpty();
            sut.Refunds.Count().Should().Be(1);
            sut.Refunds.Should().Contain(refundTxn);

            var gicanu = sut.PlayerReports.Single(pr => pr.Player.Main.Name == "Gicanu");

            gicanu.AmountPaid.Should().Be(CurrencyAmount.FromGold(40));
            gicanu.AmountDueToDate.Should().Be(CurrencyAmount.FromGold(40));
        }
Example #50
0
        public Apple()
        {
            validX5cStrings = new[] {
                "MIICRDCCAcmgAwIBAgIGAXUCfWGDMAoGCCqGSM49BAMCMEgxHDAaBgNVBAMME0FwcGxlIFdlYkF1dGhuIENBIDExEzARBgNVBAoMCkFwcGxlIEluYy4xEzARBgNVBAgMCkNhbGlmb3JuaWEwHhcNMjAxMDA3MDk0NjEyWhcNMjAxMDA4MDk1NjEyWjCBkTFJMEcGA1UEAwxANjEyNzZmYzAyZDNmZThkMTZiMzNiNTU0OWQ4MTkyMzZjODE3NDZhODNmMmU5NGE2ZTRiZWUxYzcwZjgxYjViYzEaMBgGA1UECwwRQUFBIENlcnRpZmljYXRpb24xEzARBgNVBAoMCkFwcGxlIEluYy4xEzARBgNVBAgMCkNhbGlmb3JuaWEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAR5/lkIu1EpyAk4t1TATSs0DvpmFbmHaYv1naTlPqPm/vsD2qEnDVgE6KthwVqsokNcfb82nXHKFcUjsABKG3W3o1UwUzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIE8DAzBgkqhkiG92NkCAIEJjAkoSIEIJxgAhVAs+GYNN/jfsYkRcieGylPeSzka5QTwyMO84aBMAoGCCqGSM49BAMCA2kAMGYCMQDaHBjrI75xAF7SXzyF5zSQB/Lg9PjTdyye+w7stiqy84K6lmo8d3fIptYjLQx81bsCMQCvC8MSN+aewiaU0bMsdxRbdDerCJJj3xJb3KZwloevJ3daCmCcrZrAPYfLp2kDOsg=",
                "MIICNDCCAbqgAwIBAgIQViVTlcen+0Dr4ijYJghTtjAKBggqhkjOPQQDAzBLMR8wHQYDVQQDDBZBcHBsZSBXZWJBdXRobiBSb290IENBMRMwEQYDVQQKDApBcHBsZSBJbmMuMRMwEQYDVQQIDApDYWxpZm9ybmlhMB4XDTIwMDMxODE4MzgwMVoXDTMwMDMxMzAwMDAwMFowSDEcMBoGA1UEAwwTQXBwbGUgV2ViQXV0aG4gQ0EgMTETMBEGA1UECgwKQXBwbGUgSW5jLjETMBEGA1UECAwKQ2FsaWZvcm5pYTB2MBAGByqGSM49AgEGBSuBBAAiA2IABIMuhy8mFJGBAiW59fzWu2N4tfVfP8sEW8c1mTR1/VSQRN+b/hkhF2XGmh3aBQs41FCDQBpDT7JNES1Ww+HPv8uYkf7AaWCBvvlsvHfIjd2vRqWu4d1RW1r6q5O+nAsmkaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAfBgNVHSMEGDAWgBQm12TZxXjCWmfRp95rEtAbY/HG1zAdBgNVHQ4EFgQU666CxP+hrFtR1M8kYQUAvmO9d4gwDgYDVR0PAQH/BAQDAgEGMAoGCCqGSM49BAMDA2gAMGUCMQDdixo0gaX62du052V7hB4UTCe3W4dqQYbCsUdXUDNyJ+/lVEV+9kiVDGMuXEg+cMECMCyKYETcIB/P5ZvDTSkwwUh4Udlg7Wp18etKyr44zSW4l9DIBb7wx/eLB6VxxugOBw=="
            };
            _attestationObject = CBORObject.NewMap().Add("fmt", "apple");
            var param = Fido2Tests._validCOSEParameters[0];
            X509Certificate2 root, attestnCert;
            DateTimeOffset   notBefore = DateTimeOffset.UtcNow;
            DateTimeOffset   notAfter  = notBefore.AddDays(2);
            var attDN = new X500DistinguishedName("CN=attest.apple.com, OU=Apple Authenticator Attestation, O=FIDO2-NET-LIB, C=US");

            using (var ecdsaRoot = ECDsa.Create())
            {
                var rootRequest = new CertificateRequest(rootDN, ecdsaRoot, HashAlgorithmName.SHA256);
                rootRequest.CertificateExtensions.Add(caExt);

                var     curve   = (COSE.EllipticCurve)param[2];
                ECCurve eCCurve = ECCurve.NamedCurves.nistP256;
                using (root = rootRequest.CreateSelfSigned(
                           notBefore,
                           notAfter))

                    using (var ecdsaAtt = ECDsa.Create(eCCurve))
                    {
                        var attRequest = new CertificateRequest(attDN, ecdsaAtt, HashAlgorithmName.SHA256);

                        byte[] serial = new byte[12];

                        using (var rng = RandomNumberGenerator.Create())
                        {
                            rng.GetBytes(serial);
                        }
                        using (X509Certificate2 publicOnly = attRequest.Create(
                                   root,
                                   notBefore,
                                   notAfter,
                                   serial))
                        {
                            attestnCert = publicOnly.CopyWithPrivateKey(ecdsaAtt);
                        }

                        var ecparams = ecdsaAtt.ExportParameters(true);

                        var cpk = CBORObject.NewMap();
                        cpk.Add(COSE.KeyCommonParameter.KeyType, (COSE.KeyType)param[0]);
                        cpk.Add(COSE.KeyCommonParameter.Alg, (COSE.Algorithm)param[1]);
                        cpk.Add(COSE.KeyTypeParameter.X, ecparams.Q.X);
                        cpk.Add(COSE.KeyTypeParameter.Y, ecparams.Q.Y);
                        cpk.Add(COSE.KeyTypeParameter.Crv, (COSE.EllipticCurve)param[2]);

                        var x = cpk[CBORObject.FromObject(COSE.KeyTypeParameter.X)].GetByteString();
                        var y = cpk[CBORObject.FromObject(COSE.KeyTypeParameter.Y)].GetByteString();

                        _credentialPublicKey = new CredentialPublicKey(cpk);
                        var X5c = CBORObject.NewArray()
                                  .Add(CBORObject.FromObject(attestnCert.RawData))
                                  .Add(CBORObject.FromObject(root.RawData));

                        _attestationObject.Add("attStmt", CBORObject.NewMap().Add("x5c", X5c));
                    }
            }
        }
Example #51
0
 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");
     }
 }
Example #52
0
        public DateTimeOffset GetDateTimeOffset()
        {
            DateTime       now     = DateTime.Now;
            int            hour    = Hour > 0 ? Hour : now.Hour;
            int            minute  = Minute > 0 ? Minute : now.Minute;
            int            day     = Day > 0 ? Day : now.Day;
            int            month   = Month > 0 ? Month : now.Month;
            int            year    = now.Year;
            DateTimeOffset runTime = DateBuilder.DateOf(hour, minute, 0, day, month, year);

            // month
            if (runTime.DateTime < now && Month > 0 && Month < now.Month)
            {
                runTime = runTime.AddYears(1);
            }
            // day
            if (runTime.DateTime < now && Day > 0 && Day < now.Day)
            {
                if (Month == 0)
                {
                    runTime = runTime.AddMonths(1);
                }
                else
                {
                    runTime = runTime.AddYears(1);
                }
            }
            // hour
            if (runTime.DateTime < now && Hour > 0 && Hour < now.Hour)
            {
                if (Day == 0)
                {
                    runTime = runTime.AddDays(1);
                }
                else if (Month == 0)
                {
                    runTime = runTime.AddMonths(1);
                }
                else
                {
                    runTime = runTime.AddYears(1);
                }
            }
            // minute
            if (runTime.DateTime < now && Minute > 0 && Minute < now.Minute)
            {
                if (Hour == 0)
                {
                    runTime = runTime.AddHours(1);
                }
                else if (Day == 0)
                {
                    runTime = runTime.AddDays(1);
                }
                else if (Month == 0)
                {
                    runTime = runTime.AddMonths(1);
                }
                else
                {
                    runTime = runTime.AddYears(1);
                }
            }
            return(runTime);
        }
Example #53
0
        public void Multi_Threaded_ApiFactory_Tasks(int quoteCount, int threadCount)
        {
            var config   = ApiConfigurationBuilder.Build("secrets.json");
            var provider = new ClientCredentialsFlowTokenProvider(config);

            var date = new DateTimeOffset(2018, 1, 1, 0, 0, 0, TimeSpan.Zero);

            var request = Enumerable.Range(0, quoteCount).Select(i => new UpsertQuoteRequest(
                                                                     new QuoteId(
                                                                         new QuoteSeriesId(
                                                                             provider: "DataScope",
                                                                             priceSource: "BankA",
                                                                             instrumentId: "BBG000B9XRY4",
                                                                             instrumentIdType: QuoteSeriesId.InstrumentIdTypeEnum.Figi,
                                                                             quoteType: QuoteSeriesId.QuoteTypeEnum.Price,
                                                                             field: "mid"),
                                                                         effectiveAt: date.AddDays(i)),
                                                                     metricValue: new MetricValue(
                                                                         value: 199.23m,
                                                                         unit: "USD"),
                                                                     lineage: "InternalSystem")).ToDictionary(k => k.QuoteId.EffectiveAt.ToString(), v => v);

            var tasks = Enumerable.Range(0, threadCount).Select(x => Task.Run(() =>
            {
                var factory = LusidApiFactoryBuilder.Build(config.ApiUrl, provider);
                var result  = factory.Api <IQuotesApi>().UpsertQuotes("mt-scope", request);
                Assert.That(result.Failed, Is.Empty);

                Console.WriteLine($"{DateTimeOffset.UtcNow} {Thread.CurrentThread.ManagedThreadId} {result.Values.Count}");
            }));

            Task.WaitAll(tasks.ToArray());
        }
        public static void CheckTimeNested()
        {
            HashAlgorithmName hashAlgorithm = HashAlgorithmName.SHA256;

            using (RSA rsa = RSA.Create(TestData.RsaBigExponentParams))
            {
                CertificateRequest request = new CertificateRequest("CN=Issuer", rsa, hashAlgorithm, RSASignaturePadding.Pkcs1);

                request.CertificateExtensions.Add(
                    new X509BasicConstraintsExtension(true, false, 0, true));

                DateTimeOffset now       = DateTimeOffset.UtcNow;
                DateTimeOffset notBefore = now.AddMinutes(-10);
                DateTimeOffset notAfter  = now.AddMinutes(10);

                if (notAfter.Millisecond > 900)
                {
                    // We're only going to add 1, but let's be defensive.
                    notAfter -= TimeSpan.FromMilliseconds(200);
                }

                using (X509Certificate2 issuer = request.CreateSelfSigned(notBefore, notAfter))
                {
                    request = new CertificateRequest("CN=Leaf", rsa, hashAlgorithm, RSASignaturePadding.Pkcs1);
                    byte[] serial = { 3, 1, 4, 1, 5, 9 };

                    // Boundary case, exact match: Issue+Dispose
                    request.Create(issuer, notBefore, notAfter, serial).Dispose();

                    DateTimeOffset truncatedNotBefore = new DateTimeOffset(
                        notBefore.Year,
                        notBefore.Month,
                        notBefore.Day,
                        notBefore.Hour,
                        notBefore.Minute,
                        notBefore.Second,
                        notBefore.Offset);

                    // Boundary case, the notBefore rounded down: Issue+Dispose
                    request.Create(issuer, truncatedNotBefore, notAfter, serial).Dispose();

                    // Boundary case, the notAfter plus a millisecond, same second rounded down.
                    request.Create(issuer, notBefore, notAfter.AddMilliseconds(1), serial).Dispose();//);

                    // The notBefore value a whole second earlier:
                    AssertExtensions.Throws <ArgumentException>("notBefore", () =>
                    {
                        request.Create(issuer, notBefore.AddSeconds(-1), notAfter, serial).Dispose();
                    });

                    // The notAfter value bumped past the second mark:
                    DateTimeOffset tooLate = notAfter.AddMilliseconds(1000 - notAfter.Millisecond);
                    AssertExtensions.Throws <ArgumentException>("notAfter", () =>
                    {
                        request.Create(issuer, notBefore, tooLate, serial).Dispose();
                    });

                    // And ensure that both out of range isn't magically valid again
                    AssertExtensions.Throws <ArgumentException>("notBefore", () =>
                    {
                        request.Create(issuer, notBefore.AddDays(-1), notAfter.AddDays(1), serial).Dispose();
                    });
                }
            }
        }
Example #55
0
        public static DateTimeOffset Modify(DateTimeOffset val, int field, int modType, TimeZoneInfo timeZone)
        {
            if (val.Year > 280000000)
            {
                throw new ArithmeticException("Calendar value too large for accurate calculations");
            }

            if (field == DateTimeFieldEnum.MILLISEC)
            {
                return(val);
            }

            // ----------------- Fix for LANG-59 ---------------------- START ---------------
            // see http://issues.apache.org/jira/browse/LANG-59
            //
            // Manually truncate milliseconds, seconds and minutes, rather than using
            // Calendar methods.

            var time = val.TimeInMillis();
            var done = false;

            // truncate milliseconds
            int millisecs = val.Millisecond;

            if (MODIFY_TRUNCATE == modType || millisecs < 500)
            {
                time = time - millisecs;
            }
            if (field == DateTimeFieldEnum.SECOND)
            {
                done = true;
            }

            // truncate seconds
            int seconds = val.Second;

            if (!done && (MODIFY_TRUNCATE == modType || seconds < 30))
            {
                time = time - (seconds * 1000L);
            }
            if (field == DateTimeFieldEnum.MINUTE)
            {
                done = true;
            }

            // truncate minutes
            int minutes = val.Minute;

            if (!done && (MODIFY_TRUNCATE == modType || minutes < 30))
            {
                time = time - (minutes * 60000L);
            }

            // reset time
            if (val.TimeInMillis() != time)
            {
                val = DateTimeOffsetHelper.TimeFromMillis(time, timeZone);
            }
            // ----------------- Fix for LANG-59 ----------------------- END ----------------

            var roundUp = false;

            for (int i = 0; i < Fields.Length; i++)
            {
                for (int j = 0; j < Fields[i].Length; j++)
                {
                    if (Fields[i][j] == field)
                    {
                        //This is our field... we stop looping
                        if (modType == MODIFY_CEILING || (modType == MODIFY_ROUND && roundUp))
                        {
                            if (field == ApacheCommonsDateUtils.SEMI_MONTH)
                            {
                                //This is a special case that's hard to generalize
                                //If the date is 1, we round up to 16, otherwise
                                //  we subtract 15 days and add 1 month
                                if (val.Day == 1)
                                {
                                    val = val.AddDays(15);
                                }
                                else
                                {
                                    val = val.AddDays(-15).AddMonthsLikeJava(1);
                                }
                                // ----------------- Fix for LANG-440 ---------------------- START ---------------
                            }
                            else if (field == DateTimeFieldEnum.AM_PM)
                            {
                                // This is a special case
                                // If the time is 0, we round up to 12, otherwise
                                //  we subtract 12 hours and add 1 day
                                if (val.Hour == 0)
                                {
                                    val = val.AddHours(12);
                                }
                                else
                                {
                                    val = val.AddHours(-12).AddDays(1);
                                }
                                // ----------------- Fix for LANG-440 ---------------------- END ---------------
                            }
                            else
                            {
                                //We need at add one to this field since the
                                //  last number causes us to round up
                                val = val.AddUsingField(Fields[i][0], 1);
                            }
                        }
                        return(val);
                    }
                }
                //We have various fields that are not easy roundings
                var offset    = 0;
                var offsetSet = false;
                //These are special types of fields that require different rounding rules
                switch (field)
                {
                case ApacheCommonsDateUtils.SEMI_MONTH:
                    if (Fields[i][0] == DateTimeFieldEnum.DATE)
                    {
                        //If we're going to drop the DATE field's value,
                        //  we want to do this our own way.
                        //We need to subtrace 1 since the date has a minimum of 1
                        offset = val.Day - 1;
                        //If we're above 15 days adjustment, that means we're in the
                        //  bottom half of the month and should stay accordingly.
                        if (offset >= 15)
                        {
                            offset -= 15;
                        }
                        //Record whether we're in the top or bottom half of that range
                        roundUp   = offset > 7;
                        offsetSet = true;
                    }
                    break;

                case DateTimeFieldEnum.AM_PM:
                    if (Fields[i][0] == DateTimeFieldEnum.HOUR_OF_DAY)
                    {
                        //If we're going to drop the HOUR field's value,
                        //  we want to do this our own way.
                        offset = val.Hour;
                        if (offset >= 12)
                        {
                            offset -= 12;
                        }
                        roundUp   = offset >= 6;
                        offsetSet = true;
                    }
                    break;
                }
                if (!offsetSet)
                {
                    int min = val.GetActualMinimum(Fields[i][0]);
                    int max = val.GetActualMaximum(Fields[i][0]);
                    //Calculate the offset from the minimum allowed value
                    offset = val.GetFieldValue(Fields[i][0]) - min;
                    //Set roundUp if this is more than half way between the minimum and maximum
                    roundUp = offset > ((max - min) / 2);
                }
                //We need to remove this field
                if (offset != 0)
                {
                    val = val.SetFieldValue(Fields[i][0], val.GetFieldValue(Fields[i][0]) - offset, timeZone);
                }
            }

            throw new ArgumentException("The field " + field + " is not supported");
        }
Example #56
0
 public static DateTimeOffset PreviousTimeOfDay(this DateTimeOffset dateTime, TimeSpan timeOfDay) =>
 dateTime.TimeOfDay > timeOfDay
         ? dateTime.AtTimeOfDay(timeOfDay)
         : dateTime.AddDays(-1).AtTimeOfDay(timeOfDay);
        public void TestDaylightSavingsTransitions()
        {
            // Pick a day before a spring daylight savings transition...

            DateTimeOffset startCalendar = DateBuilder.DateOf(9, 30, 17, 12, 3, 2010);

            var dailyTrigger = new CalendarIntervalTriggerImpl
            {
                StartTimeUtc       = startCalendar,
                RepeatIntervalUnit = IntervalUnit.Day,
                RepeatInterval     = 5 // every 5 days
            };

            DateTimeOffset targetCalendar = startCalendar.AddDays(10); // jump 10 days (2 intervals)

            var            fireTimes = TriggerUtils.ComputeFireTimes(dailyTrigger, null, 6);
            DateTimeOffset testTime  = fireTimes[2]; // get the third fire time

            Assert.AreEqual(targetCalendar, testTime, "Day increment result not as expected over spring 2010 daylight savings transition.");

            // And again, Pick a day before a spring daylight savings transition... (QTZ-240)

            startCalendar = new DateTime(2011, 3, 12, 1, 0, 0);

            dailyTrigger = new CalendarIntervalTriggerImpl();
            dailyTrigger.StartTimeUtc       = startCalendar;
            dailyTrigger.RepeatIntervalUnit = IntervalUnit.Day;
            dailyTrigger.RepeatInterval     = 1;       // every day

            targetCalendar = startCalendar.AddDays(2); // jump 2 days (2 intervals)

            fireTimes = TriggerUtils.ComputeFireTimes(dailyTrigger, null, 6);
            testTime  = fireTimes[2]; // get the third fire time

            Assert.AreEqual(targetCalendar, testTime, "Day increment result not as expected over spring 2011 daylight savings transition.");

            // And again, Pick a day before a spring daylight savings transition... (QTZ-240) - and prove time of day is not preserved without setPreserveHourOfDayAcrossDaylightSavings(true)

            var cetTimeZone = TimeZoneUtil.FindTimeZoneById("Central European Standard Time");

            startCalendar = TimeZoneInfo.ConvertTime(new DateTime(2011, 3, 26, 4, 0, 0), cetTimeZone);

            dailyTrigger = new CalendarIntervalTriggerImpl();
            dailyTrigger.StartTimeUtc       = startCalendar;
            dailyTrigger.RepeatIntervalUnit = IntervalUnit.Day;
            dailyTrigger.RepeatInterval     = 1; // every day

            targetCalendar = TimeZoneUtil.ConvertTime(startCalendar, cetTimeZone);
            targetCalendar = targetCalendar.AddDays(2); // jump 2 days (2 intervals)

            fireTimes = TriggerUtils.ComputeFireTimes(dailyTrigger, null, 6);

            testTime = fireTimes[2]; // get the third fire time

            DateTimeOffset testCal = TimeZoneUtil.ConvertTime(testTime, cetTimeZone);

            Assert.AreNotEqual(targetCalendar.Hour, testCal.Hour, "Day increment time-of-day result not as expected over spring 2011 daylight savings transition.");

            // And again, Pick a day before a spring daylight savings transition... (QTZ-240) - and prove time of day is preserved with setPreserveHourOfDayAcrossDaylightSavings(true)

            startCalendar = TimeZoneUtil.ConvertTime(new DateTime(2011, 3, 26, 4, 0, 0), cetTimeZone);

            dailyTrigger = new CalendarIntervalTriggerImpl();
            dailyTrigger.StartTimeUtc       = startCalendar;
            dailyTrigger.RepeatIntervalUnit = IntervalUnit.Day;
            dailyTrigger.RepeatInterval     = 1; // every day
            dailyTrigger.TimeZone           = cetTimeZone;
            dailyTrigger.PreserveHourOfDayAcrossDaylightSavings = true;

            targetCalendar = startCalendar.AddDays(2); // jump 2 days (2 intervals)

            fireTimes = TriggerUtils.ComputeFireTimes(dailyTrigger, null, 6);

            testTime = fireTimes[1]; // get the second fire time

            testCal = TimeZoneUtil.ConvertTime(testTime, cetTimeZone);

            Assert.AreEqual(targetCalendar.Hour, testCal.Hour, "Day increment time-of-day result not as expected over spring 2011 daylight savings transition.");

            // Pick a day before a fall daylight savings transition...

            startCalendar = new DateTimeOffset(2010, 10, 31, 9, 30, 17, TimeSpan.Zero);

            dailyTrigger = new CalendarIntervalTriggerImpl
            {
                StartTimeUtc       = startCalendar,
                RepeatIntervalUnit = IntervalUnit.Day,
                RepeatInterval     = 5 // every 5 days
            };

            targetCalendar = startCalendar.AddDays(15); // jump 15 days (3 intervals)

            fireTimes = TriggerUtils.ComputeFireTimes(dailyTrigger, null, 6);
            testTime  = fireTimes[3]; // get the fourth fire time

            Assert.AreEqual(targetCalendar, testTime, "Day increment result not as expected over fall daylight savings transition.");
        }
            public async Task FetchesTwoMonthsOfTimeEntriesDataIncludingTwoDaysAfterNow()
            {
                sinceParameters.Get <ITimeEntry>().Returns(now.AddMonths(-8));

                await state.Start().SingleAsync();

                var max = TimeSpan.FromDays(62);
                var min = TimeSpan.FromDays(59);

                await api.TimeEntries.Received().GetAll(
                    Arg.Is <DateTimeOffset>(start => min <= now - start && now - start <= max), Arg.Is(now.AddDays(2)));
            }
Example #59
0
		public void ArithmeticAccrossDSTBoudaries ()
		{
			DateTime dt = new DateTime (633954393584177800, DateTimeKind.Local); //Dec 3, 2009, 12:16
			DateTimeOffset dto = new DateTimeOffset (dt);
			DateTimeOffset dto2 = dto.AddDays (-60); //Should cross the late Oct boundary in most part of the world
			Assert.AreEqual (dto.Offset, dto2.Offset);
			Assert.AreEqual (dt.AddDays (-60), dto2.DateTime);
		}
Example #60
0
        private void AddConfirm_Click(object sender, RoutedEventArgs e)
        {
            /*if (MyDateName.Text == "")
             *  title = "Unknown";
             * else title = MyDateName.Text;*/
            if (title == "")
            {
                title = "Unknown";
            }
            if (MyDateLevel.Text == "")
            {
                Flyout    fly1     = new Flyout();
                TextBlock fly1text = new TextBlock();
                fly1text.Text = "请输入任务等级";
                fly1.Content  = fly1text;
                fly1.ShowAt(MyDateLevel);
                return;
            }
            if (Option1CheckBox.IsChecked == false && Option2CheckBox.IsChecked == false && Option3CheckBox.IsChecked == false &&
                Option4CheckBox.IsChecked == false && Option5CheckBox.IsChecked == false && Option6CheckBox.IsChecked == false &&
                Option7CheckBox.IsChecked == false)
            {
                Flyout    fly2     = new Flyout();
                TextBlock fly2text = new TextBlock();
                fly2text.Text = "请选择任务时间";
                fly2.Content  = fly2text;
                fly2.ShowAt(OptionsAllCheckBox);
                return;
            }

            /*if (BeginDate.Date < DateTimeOffset.Now)
             * {
             *  Flyout fly3 = new Flyout();
             *  TextBlock fly3text = new TextBlock();
             *  fly3text.Text = "请选择当前日期之后的日期";
             *  fly3.Content = fly3text;
             *  fly3.ShowAt(OptionsAllCheckBox);
             *  return;
             * }*/
            if (EndDate.Date < BeginDate.Date)
            {
                Flyout    fly4     = new Flyout();
                TextBlock fly4text = new TextBlock();
                fly4text.Text = "请选择开始日期之后的日期";
                fly4.Content  = fly4text;
                fly4.ShowAt(OptionsAllCheckBox);
                return;
            }

            /*if (OKRTaskPage.now_title == "")
             *  title = "Unknown";
             * else title = OKRTaskPage.now_title;*/
            string nlevel = MyDateLevel.Text.ToString();

            level = int.Parse(nlevel);
            int need = 0;

            if (Option1CheckBox.IsChecked == true)
            {
                DateTimeOffset today1 = BeginDate.Date;
                while (today1 <= EndDate.Date)
                {
                    if (today1.DayOfWeek == DayOfWeek.Monday)
                    {
                        need++;
                        today1 = today1.AddDays(7);
                    }
                    else
                    {
                        today1 = today1.AddDays(1);
                    }
                }
            }
            if (Option2CheckBox.IsChecked == true)
            {
                DateTimeOffset today1 = BeginDate.Date;
                while (today1 <= EndDate.Date)
                {
                    if (today1.DayOfWeek == DayOfWeek.Tuesday)
                    {
                        need++;
                        today1 = today1.AddDays(7);
                    }
                    else
                    {
                        today1 = today1.AddDays(1);
                    }
                }
            }
            if (Option3CheckBox.IsChecked == true)
            {
                DateTimeOffset today1 = BeginDate.Date;
                while (today1 <= EndDate.Date)
                {
                    if (today1.DayOfWeek == DayOfWeek.Wednesday)
                    {
                        need++;
                        today1 = today1.AddDays(7);
                    }
                    else
                    {
                        today1 = today1.AddDays(1);
                    }
                }
            }
            if (Option4CheckBox.IsChecked == true)
            {
                DateTimeOffset today1 = BeginDate.Date;
                while (today1 <= EndDate.Date)
                {
                    if (today1.DayOfWeek == DayOfWeek.Thursday)
                    {
                        need++;
                        today1 = today1.AddDays(7);
                    }
                    else
                    {
                        today1 = today1.AddDays(1);
                    }
                }
            }
            if (Option5CheckBox.IsChecked == true)
            {
                DateTimeOffset today1 = BeginDate.Date;
                while (today1 <= EndDate.Date)
                {
                    if (today1.DayOfWeek == DayOfWeek.Friday)
                    {
                        need++;
                        today1 = today1.AddDays(7);
                    }
                    else
                    {
                        today1 = today1.AddDays(1);
                    }
                }
            }
            if (Option6CheckBox.IsChecked == true)
            {
                DateTimeOffset today1 = BeginDate.Date;
                while (today1 <= EndDate.Date)
                {
                    if (today1.DayOfWeek == DayOfWeek.Saturday)
                    {
                        need++;
                        today1 = today1.AddDays(7);
                    }
                    else
                    {
                        today1 = today1.AddDays(1);
                    }
                }
            }
            if (Option7CheckBox.IsChecked == true)
            {
                DateTimeOffset today1 = BeginDate.Date;
                while (today1 <= EndDate.Date)
                {
                    if (today1.DayOfWeek == DayOfWeek.Sunday)
                    {
                        need++;
                        today1 = today1.AddDays(7);
                    }
                    else
                    {
                        today1 = today1.AddDays(1);
                    }
                }
            }
            MainPage.VM.AddNeedItems(title, need);
            DateTimeOffset today = BeginDate.Date;

            while (today <= EndDate.Date)
            {
                if (Option1CheckBox.IsChecked == true && today.DayOfWeek == DayOfWeek.Monday)
                {
                    MainPage.VM.AddOkrItems(level, today, title, need);
                }
                else if (Option2CheckBox.IsChecked == true && today.DayOfWeek == DayOfWeek.Tuesday)
                {
                    MainPage.VM.AddOkrItems(level, today, title, need);
                }
                else if (Option3CheckBox.IsChecked == true && today.DayOfWeek == DayOfWeek.Wednesday)
                {
                    MainPage.VM.AddOkrItems(level, today, title, need);
                }
                else if (Option4CheckBox.IsChecked == true && today.DayOfWeek == DayOfWeek.Thursday)
                {
                    MainPage.VM.AddOkrItems(level, today, title, need);
                }
                else if (Option5CheckBox.IsChecked == true && today.DayOfWeek == DayOfWeek.Friday)
                {
                    MainPage.VM.AddOkrItems(level, today, title, need);
                }
                else if (Option6CheckBox.IsChecked == true && today.DayOfWeek == DayOfWeek.Saturday)
                {
                    MainPage.VM.AddOkrItems(level, today, title, need);
                }
                else if (Option7CheckBox.IsChecked == true && today.DayOfWeek == DayOfWeek.Sunday)
                {
                    MainPage.VM.AddOkrItems(level, today, title, need);
                }
                today = today.AddDays(1);
            }
            Flyout    fly     = new Flyout();
            TextBlock flytext = new TextBlock();

            flytext.Text = "保存成功";
            fly.Content  = flytext;
            fly.ShowAt(AddConfirm);
            //返回有问题
            //Frame.Navigate(typeof(OKRTaskPage));
        }