public void HasStartTest() { // 현재부터 ~ 쭉 // var timeRange = new TimeBlock(ClockProxy.Clock.Now, null); timeRange.HasStart.Should().Be.True(); timeRange.HasEnd.Should().Be.False(); }
public void MomentTest() { var moment = ClockProxy.Clock.Now; var timeBlock = new TimeBlock(moment); timeBlock.Start.Should().Be(moment); timeBlock.End.Should().Be(moment); timeBlock.Duration.Should().Be(TimeSpec.MinPeriodDuration); timeBlock.IsAnytime.Should().Be.False(); timeBlock.IsMoment.Should().Be.True(); timeBlock.HasPeriod.Should().Be.True(); }
public void DefaultTest() { var timeBlock = new TimeBlock(); timeBlock.Should().Not.Be.EqualTo(TimeBlock.Anytime); // not readonly .vs. readonly timeBlock.GetRelation(TimeBlock.Anytime).Should().Be(PeriodRelation.ExactMatch); TimeBlock.Anytime.IsAnytime.Should().Be.True(); TimeBlock.Anytime.IsMoment.Should().Be.False(); TimeBlock.Anytime.IsReadOnly.Should().Be.True(); TimeBlock.Anytime.HasStart.Should().Be.False(); TimeBlock.Anytime.HasEnd.Should().Be.False(); TimeBlock.Anytime.HasPeriod.Should().Be.False(); }
public void CopyTest() { TimeBlock readOnlyTimeBlock = new TimeBlock(_start, _duration); Assert.AreEqual(readOnlyTimeBlock.Copy(TimeSpan.Zero), readOnlyTimeBlock); TimeBlock timeBlock = new TimeBlock(_start, _duration); Assert.AreEqual(timeBlock.Start, _start); Assert.AreEqual(timeBlock.End, _end); Assert.AreEqual(timeBlock.Duration, _duration); ITimeBlock noMoveTimeBlock = timeBlock.Copy(TimeSpan.Zero); Assert.AreEqual(noMoveTimeBlock.Start, _start); Assert.AreEqual(noMoveTimeBlock.End, _end); Assert.AreEqual(noMoveTimeBlock.Duration, _duration); TimeSpan forwardOffset = new TimeSpan(2, 30, 15); ITimeBlock forwardTimeBlock = timeBlock.Copy(forwardOffset); Assert.AreEqual(forwardTimeBlock.Start, _start.Add(forwardOffset)); Assert.AreEqual(forwardTimeBlock.End, _end.Add(forwardOffset)); Assert.AreEqual(forwardTimeBlock.Duration, _duration); TimeSpan backwardOffset = new TimeSpan(-1, 10, 30); ITimeBlock backwardTimeBlock = timeBlock.Copy(backwardOffset); Assert.AreEqual(backwardTimeBlock.Start, _start.Add(backwardOffset)); Assert.AreEqual(backwardTimeBlock.End, _end.Add(backwardOffset)); Assert.AreEqual(backwardTimeBlock.Duration, _duration); }
public void HasInsideDateTimeTest() { TimeBlock timeBlock = new TimeBlock(_start, _duration); Assert.AreEqual(timeBlock.Duration, _duration); // start Assert.IsFalse(timeBlock.HasInside(_start.AddMilliseconds(-1))); Assert.IsTrue(timeBlock.HasInside(_start)); Assert.IsTrue(timeBlock.HasInside(_start.AddMilliseconds(1))); // end Assert.IsTrue(timeBlock.HasInside(_end.AddMilliseconds(-1))); Assert.IsTrue(timeBlock.HasInside(_end)); Assert.IsFalse(timeBlock.HasInside(_end.AddMilliseconds(1))); }
public void DurationOutOfRangeTest() { TimeBlock timeBlock = new TimeBlock(_start, _duration); Assert.Throws<InvalidOperationException>(() => timeBlock.Duration = TimeSpan.FromMilliseconds(1).Negate()); }
public void EndReadOnlyTest() { var timeBlock = new TimeBlock(ClockProxy.Clock.Now.AddHours(-1), ClockProxy.Clock.Now, true); Assert.Throws<InvalidOperationException>(() => timeBlock.End = timeBlock.End.AddHours(1)); }
public void StartTest() { var timeBlock = new TimeBlock(_start, _duration); timeBlock.Start.Should().Be(_start); timeBlock.Duration.Should().Be(_duration); var changedStart = _start.AddHours(-1); timeBlock.Start = changedStart; timeBlock.Start.Should().Be(changedStart); timeBlock.Duration.Should().Be(_duration); }
private void OnAddTimeBlock(object sender, RoutedEventArgs e) { TimeBlock tb = new TimeBlock(); Data.TimeBlocks.Add(tb); }
public void GetIntersectionTest() { TimeBlock readOnlyTimeBlock = new TimeBlock(_start, _duration); Assert.AreEqual(readOnlyTimeBlock.GetIntersectionBlock(readOnlyTimeBlock), new TimeBlock(readOnlyTimeBlock)); TimeBlock timeBlock = new TimeBlock(_start, _duration); // before ITimeBlock before1 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddHours(-2), _start.AddHours(-1))); Assert.AreEqual(before1, null); ITimeBlock before2 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddMilliseconds(-1), _start)); Assert.AreEqual(before2, new TimeBlock(_start)); ITimeBlock before3 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddMilliseconds(-1), _start.AddMilliseconds(1))); Assert.AreEqual(before3, new TimeBlock(_start, _start.AddMilliseconds(1))); // after ITimeBlock after1 = timeBlock.GetIntersectionBlock(new TimeBlock(_end.AddHours(1), _end.AddHours(2))); Assert.AreEqual(after1, null); ITimeBlock after2 = timeBlock.GetIntersectionBlock(new TimeBlock(_end, _end.AddMilliseconds(1))); Assert.AreEqual(after2, new TimeBlock(_end)); ITimeBlock after3 = timeBlock.GetIntersectionBlock(new TimeBlock(_end.AddMilliseconds(-1), _end.AddMilliseconds(1))); Assert.AreEqual(after3, new TimeBlock(_end.AddMilliseconds(-1), _end)); // intersect Assert.AreEqual(timeBlock.GetIntersectionBlock(timeBlock), timeBlock); ITimeBlock itersect1 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddMilliseconds(-1), _end.AddMilliseconds(1))); Assert.AreEqual(itersect1, timeBlock); ITimeBlock itersect2 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddMilliseconds(1), _end.AddMilliseconds(-1))); Assert.AreEqual(itersect2, new TimeBlock(_start.AddMilliseconds(1), _end.AddMilliseconds(-1))); }
public void Update(TimeBlock timeBlock) { this.timeBlock = timeBlock; RaisePropertyChanged(() => Date); RaisePropertyChanged(() => Time); }
public TimeBlockListItemViewModel(TimeBlock timeBlock) { this.timeBlock = timeBlock; }
public AverageShareOfBlockRewardDT(TimeBlock averageBlockCreationSpan, double blockRewardPerBlock, TimeBlock duration, IHashRate minerHashRate, IHashRate networkHashRate) { AverageBlockCreationSpan = averageBlockCreationSpan ?? throw new ArgumentNullException(nameof(averageBlockCreationSpan)); BlockRewardPerBlock = blockRewardPerBlock; Duration = duration ?? throw new ArgumentNullException(nameof(duration)); MinerHashRate = minerHashRate ?? throw new ArgumentNullException(nameof(minerHashRate)); NetworkHashRate = networkHashRate ?? throw new ArgumentNullException(nameof(networkHashRate)); }
bool BlockIsToday(TimeBlock timeBlock) { return(timeBlock.Start.Date == DateTime.Today); }
/// <summary> /// This method is here to add and position existing time blocks. /// Assume this method is called by the engine, and links to the /// NodeEditor.DialogueBlockNode.LinkedTimeblock /// </summary> /// <param name="timeBlock"></param> public void AddExistingTimeblockToTimeline(TimeBlock timeBlock, int timelineIndex) { timelines[timelineIndex].AddTimeBlock(timeBlock, TimeWidth); }
private void SetSnapLocation(List <Timeline> timelines, TimeBlock desiredsnapper, int timeline) { }
public void GetPreviousPeriodTest() { var readOnlyTimeBlock = new TimeBlock(_start, _duration, true); Assert.IsTrue(readOnlyTimeBlock.GetPreviousBlock().IsReadOnly); var timeBlock = new TimeBlock(_start, _duration); Assert.AreEqual(timeBlock.Start, _start); Assert.AreEqual(timeBlock.End, _end); Assert.AreEqual(timeBlock.Duration, _duration); var previousTimeBlock = timeBlock.GetPreviousBlock(); Assert.AreEqual(previousTimeBlock.Start, _start.Subtract(_duration)); Assert.AreEqual(previousTimeBlock.End, _start); Assert.AreEqual(previousTimeBlock.Duration, _duration); var previousOffset = TimeSpan.FromHours(1).Negate(); var previousOffsetTimeBlock = timeBlock.GetPreviousBlock(previousOffset); previousOffsetTimeBlock.Start.Should().Be(_start.Subtract(_duration).Add(previousOffset)); previousOffsetTimeBlock.End.Should().Be(_end.Subtract(_duration).Add(previousOffset)); previousOffsetTimeBlock.Duration.Should().Be(_duration); }
public void EqualsTest() { var timeBlock1 = new TimeBlock(_start, _duration); var timeBlock2 = new TimeBlock(_start, _duration); timeBlock1.Should().Be(timeBlock2); var timeBlock3 = new TimeBlock(_start.AddMilliseconds(-1), _end.AddMilliseconds(1)); timeBlock1.Should().Not.Be(timeBlock3); }
public void HasEndTest() { // 현재까지 var timeBlock = new TimeBlock(null, ClockProxy.Clock.Now); timeBlock.HasStart.Should().Be.False(); timeBlock.HasEnd.Should().Be.True(); }
public async Task Init(Guid roomId, DateTime dateTime) { _roomId = roomId; _dateTime = dateTime; try { var roomModel = await _bookingService.GetRoomAsync(ApiPriority.UserInitiated, roomId); var roomReservationsForToday = await _bookingService.GetAllReservationsForDayAsync(ApiPriority.UserInitiated, _dateTime.Year, _dateTime.DayOfYear); roomReservationsForToday = roomReservationsForToday.Where(r => r.RoomId == roomId).ToList(); _allMembers = await _userService.GetAllPublicUsersAsync(ApiPriority.UserInitiated); var startHour = 6; var endHour = 24; if (roomModel?.OpeningInformation != null) { // Check opening hours var openingDay = GetOpeningInfo(roomModel.OpeningInformation, dateTime.DayOfWeek); startHour = openingDay.HourOpen; endHour = openingDay.HourClose; } //if (dateTime.Year == DateTime.Now.Year && dateTime.DayOfYear == DateTime.Now.DayOfYear) //{ // // Is today check current hour // if (DateTime.Now.Hour > startHour) // { // // Later then opening hour // startHour = DateTime.Now.Hour; // } // else if (DateTime.Now.Hour > endHour) // { // // Already closed // startHour = 24; // } // // Remove reservations that have already passed // roomReservationsForToday = roomReservationsForToday.Where(r => r.ReservationEnd.Hour < startHour).ToList(); // //foreach (var roomReservationModel in roomReservationsForToday.wh) // //{ // // // Change start date to start of reservation possibilities // // roomReservationModel.ReservationStart = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, startHour, 0, 0); // //} //} if (startHour != 24) { var startTime = new TimePickerData(startHour, 0); var endTime = new TimePickerData(endHour, 0); StartEndTime = new TimeBlock(startTime, endTime); UpdateReservations(roomReservationsForToday); } } catch (Exception ex) { ExceptionService.HandleException(ex); } }
public override ITimePeriod GetTimePeriod(DateTime baseDate) { ITimePeriod result = null; if (NumericDate.IsMatch(Text)) { DateTime pointInTime; var dateParts = Text.Split('-', '/'); var commonDate = string.Join("-", dateParts); var formats = new string[] { "yyyy-MM-dd", "d-M-yyyy", "M-d-yyyy" }; if (!DateTime.TryParseExact(commonDate, formats, null, System.Globalization.DateTimeStyles.None, out pointInTime)) { return(null); } result = new Day(pointInTime); } else if (LongFormatDate.IsMatch(Text)) { var retrievedDay = LongFormatRetrieveDay.Match(Text).Value; var parsedDay = 1; if (retrievedDay.Length > 0) { //Apply date rule if value contains a date parsedDay = int.Parse(retrievedDay); } //Enforce valid date if (parsedDay > 31) { return(null); } var retrievedMonth = ""; var parsedMonth = 1; var matchedNames = NameRetrieve.Matches(Text).Cast <Match>(); foreach (var match in matchedNames) { if (match.Value.Length > 2) { //Apply next weekday rule if value looks like it has weekday details //Note: This makes the assumption that the sentence infers a future date var weekDay = GetNextDateFromWeekDay(match.Value, baseDate); if (weekDay > baseDate) { parsedDay = weekDay.Day; continue; } //Apply month rule if value looks like it has month details var month = GetMonthFromName(match.Value); if (month != -1) { retrievedMonth = match.Value; parsedMonth = month; continue; } } } var retrievedYear = LongFormatRetrieveYear.Match(Text).Value; var parsedYear = baseDate.Year; if (retrievedYear.Length > 0) { //Apply year rule if the value contains a year parsedYear = int.Parse(retrievedYear); } //Apply base month if no month or year details were found if (retrievedMonth.Length == 0 && retrievedYear.Length == 0) { parsedMonth = baseDate.Month; } //Handle that the parsed date is allowed for the given month var lastDayOfMonth = new Month(parsedYear, (YearMonth)parsedMonth).End; if (parsedDay > lastDayOfMonth.Day) { return(null); } var leadingDate = new DateTime(parsedYear, parsedMonth, parsedDay); var trailingDate = leadingDate; //When value is specific to the... if (retrievedDay.Length > 0) { //Day trailingDate = new Day(trailingDate).End; } else if (retrievedMonth.Length > 0) { //Month trailingDate = new Month(trailingDate).End; } else if (retrievedYear.Length > 0) { //Year trailingDate = new Year(trailingDate).End; } //Apply rules for open-ended date if (Text.ToLower().StartsWith("before")) { result = new TimeRange(TimeSpec.MinPeriodDate, leadingDate); } else if (Text.ToLower().StartsWith("after")) { result = new TimeRange(trailingDate, TimeSpec.MaxPeriodDate); } else { result = new TimeRange(leadingDate, trailingDate); } } else if (FormalDayFirstDate.IsMatch(Text) || FormalMonthFirstDate.IsMatch(Text)) { var dateParts = Text.Split(new[] { ", ", " " }, StringSplitOptions.RemoveEmptyEntries); var retrievedDay = ""; var retrievedMonth = ""; //Work out the order of day/month if (FormalDayFirstDate.IsMatch(Text)) { retrievedDay = dateParts[0]; retrievedMonth = dateParts[1]; } else { retrievedDay = dateParts[1]; retrievedMonth = dateParts[0]; } var parsedDay = int.Parse(retrievedDay); //Check if the retrieved month can at least partial match a month var nameMatch = NameRetrieve.Match(retrievedMonth).Value; var month = Months.Where(m => m.StartsWith(nameMatch)).FirstOrDefault(); if (month == null) { return(null); } var parsedMonth = GetMonthFromName(month); var parsedYear = baseDate.Year; if (dateParts.Length == 3) { parsedYear = int.Parse(dateParts[2]); } //Handle that the parsed date is allowed for the given month var lastDayOfMonth = new Month(parsedYear, (YearMonth)parsedMonth).End; if (parsedDay > lastDayOfMonth.Day) { return(null); } var pointInTime = new DateTime(parsedYear, parsedMonth, parsedDay); result = new TimeBlock(pointInTime, new Day(pointInTime).End); } else if (OnWeekdayDate.IsMatch(Text)) { var retrievedWeekday = WeekdayNameRetrieve.Match(Text).Value; var weekDay = Days.Where(d => d.StartsWith(retrievedWeekday)).FirstOrDefault(); if (weekDay != null) { //Note: This makes the assumption that the sentence infers a future date var pointInTime = GetNextDateFromWeekDay(weekDay, baseDate); result = new TimeBlock(pointInTime, new Day(pointInTime).End); } else { return(null); } } else { //Must match one of the specific date formats return(null); } return(result); }
public void NonMomentTest() { var timeBlock = new TimeBlock(ClockProxy.Clock.Now, TimeSpec.MinPositiveDuration); timeBlock.IsMoment.Should().Be.False(); timeBlock.Duration.Should().Be(TimeSpec.MinPositiveDuration); }
private static List <Renderable> ReadUsage(Dictionary <string, AnimationDef> animDefs, Dictionary <string, CharSet> charsets, Dictionary <string, TextDef> textDefs, Dictionary <string, UsageGroup> groupDefs, XmlNode time, TimeBlock parent) { List <Renderable> objects = new List <Renderable>(); for (int i = 0; i < time.ChildNodes.Count; i++) { XmlNode use = time.ChildNodes[i]; if (use.Name.ToLower() == "useanim") { //AnimationDef aDef = (from ad in animDefs // where ad.Name == use.Attributes["name"].Value // select ad).ToList()[0]; Animation a = new Animation(parent, animDefs[use.Attributes["name"].Value]) { X = int.Parse(use.Attributes["x"].Value), Y = int.Parse(use.Attributes["y"].Value) }; ReadRenderableParams(i, use, a); // read animation attributes a.Attributes = ReadUsageAttributes(use); objects.Add(a); } else if (use.Name.ToLower() == "usetext") { //TextDef tDef = (from t in textDefs // where t.Name == use.Attributes["name"].Value // select t).ToList()[0]; TextDef tdef; if (use.Attributes["text"] != null && use.Attributes["charset"] != null) { tdef = new TextDef() { CharacterSet = charsets[use.Attributes["charset"].Value], Value = use.Attributes["text"].Value }; } else { tdef = textDefs[use.Attributes["name"].Value]; } Text txt = new Text(parent, tdef) { X = int.Parse(use.Attributes["x"].Value), Y = int.Parse(use.Attributes["y"].Value), }; ReadRenderableParams(i, use, txt); // read text attributes txt.Attributes = ReadUsageAttributes(use); objects.Add(txt); } else if (use.Name.ToLower() == "usegroup") { UsageGroup g = groupDefs[use.Attributes["name"].Value]; foreach (Renderable o in g.Objects) { Renderable oClone = o.Clone(); oClone.ParentBlock = parent; objects.Add(oClone); } } } return(objects); }
public static double AverageShareOfBlockRewardPerSpanSafe(AverageShareOfBlockRewardDT data, TimeBlock timeSpan) { // ToDo: Add parameter checking return(AverageShareOfBlockRewardPerSpanFast(data, timeSpan)); }
public static string GetDetail(DateTime now, DateTime timeToDescribe) { TimeBlock timeBlock = GetTimeBlock(now, timeToDescribe); return(GetDetail(timeBlock, timeToDescribe)); }
public void EndTest() { var timeBlock = new TimeBlock(_duration, _end); Assert.AreEqual(timeBlock.End, _end); Assert.AreEqual(timeBlock.Duration, _duration); DateTime changedEnd = _end.AddHours(1); timeBlock.End = changedEnd; Assert.AreEqual(timeBlock.End, changedEnd); Assert.AreEqual(timeBlock.Duration, _duration); }
public void StartReadOnlyTest() { TimeBlock timeBlock = new TimeBlock(ClockProxy.Clock.Now, ClockProxy.Clock.Now.AddHours(1), true); timeBlock.Start = timeBlock.Start.AddHours(-1); } // StartReadOnlyTest
public void MaxDurationOutOfRangeTest() { TimeBlock timeBlock = new TimeBlock(_start, _duration); Assert.Throws<ArgumentOutOfRangeException>(() => timeBlock.Duration = TimeSpec.MaxPeriodDuration); }
public void EndReadOnlyTest() { TimeBlock timeBlock = new TimeBlock(ClockProxy.Clock.Now.AddHours(-1), ClockProxy.Clock.Now, true); timeBlock.End = timeBlock.End.AddHours(1); } // EndReadOnlyTest
public void DurationFromEndTest() { TimeBlock timeBlock = new TimeBlock(_start, _duration); Assert.AreEqual(timeBlock.Start, _start); Assert.AreEqual(timeBlock.End, _end); Assert.AreEqual(timeBlock.Duration, _duration); TimeSpan delta = TimeSpan.FromHours(1); TimeSpan newDuration = timeBlock.Duration + delta; timeBlock.DurationFromEnd(newDuration); Assert.AreEqual(timeBlock.Start, _start.Subtract(delta)); Assert.AreEqual(timeBlock.End, _end); Assert.AreEqual(timeBlock.Duration, newDuration); timeBlock.DurationFromEnd(TimeSpec.MinPeriodDuration); Assert.AreEqual(timeBlock.Duration, TimeSpec.MinPeriodDuration); }
public void MaxDurationOutOfRangeTest() { TimeBlock timeBlock = new TimeBlock(start, duration); timeBlock.Duration = TimeSpec.MaxPeriodDuration; } // MaxDurationOutOfRangeTest
public void HasInsidePeriodTest() { TimeBlock timeBlock = new TimeBlock(_start, _duration); Assert.AreEqual(timeBlock.Duration, _duration); // before TimeBlock before1 = new TimeBlock(_start.AddHours(-2), _start.AddHours(-1)); Assert.IsFalse(timeBlock.HasInside(before1)); TimeBlock before2 = new TimeBlock(_start.AddMilliseconds(-1), _end); Assert.IsFalse(timeBlock.HasInside(before2)); TimeBlock before3 = new TimeBlock(_start.AddMilliseconds(-1), _start); Assert.IsFalse(timeBlock.HasInside(before3)); // after TimeBlock after1 = new TimeBlock(_end.AddHours(1), _end.AddHours(2)); Assert.IsFalse(timeBlock.HasInside(after1)); TimeBlock after2 = new TimeBlock(_start, _end.AddMilliseconds(1)); Assert.IsFalse(timeBlock.HasInside(after2)); TimeBlock after3 = new TimeBlock(_end, _end.AddMilliseconds(1)); Assert.IsFalse(timeBlock.HasInside(after3)); // inside Assert.IsTrue(timeBlock.HasInside(timeBlock)); TimeBlock inside1 = new TimeBlock(_start.AddMilliseconds(1), _end); Assert.IsTrue(timeBlock.HasInside(inside1)); TimeBlock inside2 = new TimeBlock(_start.AddMilliseconds(1), _end.AddMilliseconds(-1)); Assert.IsTrue(timeBlock.HasInside(inside2)); TimeBlock inside3 = new TimeBlock(_start, _end.AddMilliseconds(-1)); Assert.IsTrue(timeBlock.HasInside(inside3)); }
public void DurationOutOfRangeTest() { TimeBlock timeBlock = new TimeBlock(start, duration); timeBlock.Duration = Duration.Millisecond.Negate(); } // DurationOutOfRangeTest
public void MoveTest() { TimeBlock timeBlockMoveZero = new TimeBlock(_start, _duration); timeBlockMoveZero.Move(TimeSpan.Zero); Assert.AreEqual(timeBlockMoveZero.Start, _start); Assert.AreEqual(timeBlockMoveZero.End, _end); Assert.AreEqual(timeBlockMoveZero.Duration, _duration); TimeBlock timeBlockMoveForward = new TimeBlock(_start, _duration); TimeSpan forwardOffset = new TimeSpan(2, 30, 15); timeBlockMoveForward.Move(forwardOffset); Assert.AreEqual(timeBlockMoveForward.Start, _start.Add(forwardOffset)); Assert.AreEqual(timeBlockMoveForward.End, _end.Add(forwardOffset)); TimeBlock timeBlockMoveBackward = new TimeBlock(_start, _duration); TimeSpan backwardOffset = new TimeSpan(-1, 10, 30); timeBlockMoveBackward.Move(backwardOffset); Assert.AreEqual(timeBlockMoveBackward.Start, _start.Add(backwardOffset)); Assert.AreEqual(timeBlockMoveBackward.End, _end.Add(backwardOffset)); }
/// <summary> /// Gets the Agents Calendar view. /// </summary> /// <param name="ssoToken">The sso access token used to make request against graph apis.</param> /// <param name="constraints">The time constraint for finding calendar view.</param> /// /// <param name="azureADSettings">Azure AD configuration settings.</param> /// <returns>A <see cref="Task{TResult}"/> representing the result of the asynchronous operation.</returns> public static async Task<GraphResponse<IEnumerable<MeetingDetails>>> GetCalendarViewAsync(string ssoToken, TimeBlock constraints, AzureADSettings azureADSettings) { var authProvider = CreateOnBehalfOfProvider(azureADSettings, new[] { "Calendars.Read" }); GraphServiceClient graphServiceClient = new GraphServiceClient(authProvider); var startDateTimeParam = Uri.EscapeDataString(constraints.StartDateTime.ToString("o")); var endDateTimeParam = Uri.EscapeDataString(constraints.EndDateTime.ToString("o")); var queryOptions = new List<QueryOption>() { new QueryOption("startdatetime", startDateTimeParam), new QueryOption("enddatetime", endDateTimeParam), }; GraphResponse<IEnumerable<MeetingDetails>> response = new GraphResponse<IEnumerable<MeetingDetails>>(); try { var page = await graphServiceClient.Me .CalendarView.Request(queryOptions) .WithUserAssertion(new UserAssertion(ssoToken)) .GetAsync(); List<MeetingDetails> result = new List<MeetingDetails>(); while (page != null) { var meetingList = page.CurrentPage; foreach (var meeting in meetingList) { result.Add(new MeetingDetails { Subject = meeting.Subject, MeetingTime = new TimeBlock { StartDateTime = meeting.Start.ToDateTimeOffset().ToUniversalTime(), EndDateTime = meeting.End.ToDateTimeOffset().ToUniversalTime(), }, }); } if (page.NextPageRequest == null) { break; } page = await page.NextPageRequest.GetAsync(); } response.Result = result.ToImmutableList(); return response; } catch (Exception e) { response.FailureReason = e.Message; response.Result = new List<MeetingDetails>(); } return response; }
public void GetNextPeriodTest() { TimeBlock readOnlyTimeBlock = new TimeBlock(_start, _duration, true); Assert.IsTrue(readOnlyTimeBlock.GetNextBlock().IsReadOnly); TimeBlock timeBlock = new TimeBlock(_start, _duration); Assert.AreEqual(timeBlock.Start, _start); Assert.AreEqual(timeBlock.End, _end); Assert.AreEqual(timeBlock.Duration, _duration); ITimeBlock nextTimeBlock = timeBlock.GetNextBlock(); Assert.AreEqual(nextTimeBlock.Start, _end); Assert.AreEqual(nextTimeBlock.End, _end.Add(_duration)); Assert.AreEqual(nextTimeBlock.Duration, _duration); TimeSpan nextOffset = TimeSpan.FromHours(1); ITimeBlock nextOffsetTimeBlock = timeBlock.GetNextBlock(nextOffset); Assert.AreEqual(nextOffsetTimeBlock.Start, _end.Add(nextOffset)); Assert.AreEqual(nextOffsetTimeBlock.End, _end.Add(_duration + nextOffset)); Assert.AreEqual(nextOffsetTimeBlock.Duration, _duration); }
public void MomentByPeriodTest() { TimeBlock timeBlock = new TimeBlock(ClockProxy.Clock.Now, TimeSpan.Zero); Assert.True(timeBlock.IsMoment); } // MomentByPeriodTest
public void IntersectsWithDurationTest() { TimeBlock timeBlock = new TimeBlock(_start, _duration); // before TimeBlock before1 = new TimeBlock(_start.AddHours(-2), _start.AddHours(-1)); Assert.IsFalse(timeBlock.IntersectsWith(before1)); TimeBlock before2 = new TimeBlock(_start.AddMilliseconds(-1), _start); Assert.IsTrue(timeBlock.IntersectsWith(before2)); TimeBlock before3 = new TimeBlock(_start.AddMilliseconds(-1), _start.AddMilliseconds(1)); Assert.IsTrue(timeBlock.IntersectsWith(before3)); // after TimeBlock after1 = new TimeBlock(_end.AddHours(1), _end.AddHours(2)); Assert.IsFalse(timeBlock.IntersectsWith(after1)); TimeBlock after2 = new TimeBlock(_end, _end.AddMilliseconds(1)); Assert.IsTrue(timeBlock.IntersectsWith(after2)); TimeBlock after3 = new TimeBlock(_end.AddMilliseconds(-1), _end.AddMilliseconds(1)); Assert.IsTrue(timeBlock.IntersectsWith(after3)); // intersect Assert.IsTrue(timeBlock.IntersectsWith(timeBlock)); TimeBlock itersect1 = new TimeBlock(_start.AddMilliseconds(-1), _end.AddMilliseconds(1)); Assert.IsTrue(timeBlock.IntersectsWith(itersect1)); TimeBlock itersect2 = new TimeBlock(_start.AddMilliseconds(-1), _start.AddMilliseconds(1)); Assert.IsTrue(timeBlock.IntersectsWith(itersect2)); TimeBlock itersect3 = new TimeBlock(_end.AddMilliseconds(-1), _end.AddMilliseconds(1)); Assert.IsTrue(timeBlock.IntersectsWith(itersect3)); }
// Start is called before the first frame update void Start() { CurrentTime = new TimeBlock(); }
public void IsSamePeriodTest() { TimeBlock timeRange1 = new TimeBlock(_start, _duration); TimeBlock timeRange2 = new TimeBlock(_start, _duration); Assert.IsTrue(timeRange1.IsSamePeriod(timeRange1)); Assert.IsTrue(timeRange2.IsSamePeriod(timeRange2)); Assert.IsTrue(timeRange1.IsSamePeriod(timeRange2)); Assert.IsTrue(timeRange2.IsSamePeriod(timeRange1)); Assert.IsFalse(timeRange1.IsSamePeriod(TimeBlock.Anytime)); Assert.IsFalse(timeRange2.IsSamePeriod(TimeBlock.Anytime)); timeRange1.Move(new TimeSpan(1)); Assert.IsFalse(timeRange1.IsSamePeriod(timeRange2)); Assert.IsFalse(timeRange2.IsSamePeriod(timeRange1)); timeRange1.Move(new TimeSpan(-1)); Assert.IsTrue(timeRange1.IsSamePeriod(timeRange2)); Assert.IsTrue(timeRange2.IsSamePeriod(timeRange1)); }
private void DrawBackbuffer(int totalDuration) { int height = (ShowLegend ? Height - 20 : Height); using (Graphics g = Graphics.FromImage(backBuffer)) { g.Clear(Color.White); for (int i = 0; i < Animation.Flow.TimeBlocks.Count; i++) { TimeBlock tb = Animation.Flow.TimeBlocks[i]; int left = (int)(((float)tb.From / (float)totalDuration) * Width); int right = (int)(((float)tb.To / (float)totalDuration) * Width); Brush b = new SolidBrush(GetColorFrom(i)); g.FillRectangle(b, new Rectangle(left, 0, right - left + 1, height)); } int blockHeight = (height / sortedRenderables.Count); for (int j = 0; j < sortedRenderables.Count; j++) { foreach (Renderable r in sortedRenderables[j]) { int currectRStartMs = r.ParentBlock.From + r.StartMs; int currentREndMs = r.ParentBlock.From + r.StartMs + r.TotalTime; int leftRender = (int)(((float)currectRStartMs / (float)totalDuration) * (Width - 1)); int rightRender = (int)(((float)currentREndMs / (float)totalDuration) * (Width - 1)); Brush fillColor = Brushes.Black; if (r.Category == Color.Empty) { if (r is Animation) { fillColor = Brushes.Yellow; } else if (r is Text) { fillColor = Brushes.White; } } else { fillColor = new SolidBrush(r.Category); } g.FillRectangle(fillColor, new Rectangle(leftRender, j * blockHeight, rightRender - leftRender, blockHeight)); g.DrawRectangle(Pens.Black, new Rectangle(leftRender, j * blockHeight, rightRender - leftRender, blockHeight)); } } if (ShowLegend) { // draw legend int curms = 0; while (curms < totalDuration) { int offset = (int)(((float)curms / (float)totalDuration) * (Width - 1)); g.DrawLine(Pens.Black, new Point(offset, height), new Point(offset, height + 2)); SizeF strSize = g.MeasureString((curms / 1000).ToString(), Font); g.DrawString((curms / 1000).ToString(), Font, Brushes.Black, new PointF(offset - strSize.Width / 2f, height + 3)); curms += 1000; } } } updateBackbuffer = false; }
public void ResetTest() { TimeBlock timeBlock = new TimeBlock(_start, _duration); Assert.AreEqual(timeBlock.Start, _start); Assert.IsTrue(timeBlock.HasStart); Assert.AreEqual(timeBlock.End, _end); Assert.IsTrue(timeBlock.HasEnd); Assert.AreEqual(timeBlock.Duration, _duration); timeBlock.Reset(); Assert.AreEqual(timeBlock.Start, TimeSpec.MinPeriodTime); Assert.IsFalse(timeBlock.HasStart); Assert.AreEqual(timeBlock.End, TimeSpec.MaxPeriodTime); Assert.IsFalse(timeBlock.HasEnd); }
public ClaymoreMinerStatus(int iD, ClaymoreMinerStatusDetails minerStatusDetails, string statusQueryError, string version, TimeBlock moment) : base(iD, minerStatusDetails, statusQueryError, version, moment) { }
public void MomentByPeriodTest() { var timeBlock = new TimeBlock(ClockProxy.Clock.Now, TimeSpan.Zero); timeBlock.IsMoment.Should().Be.True(); }
public async Task <IActionResult> GetMeetingDetailsAsync([FromHeader] string authorization, [FromBody] TimeBlock constraints) { string ssoToken = authorization.Substring("Bearer".Length + 1); var graphMeetingDetailsResponse = await GraphUtil.GetCalendarViewAsync(ssoToken, constraints, this.azureADOptions.Value); if (!graphMeetingDetailsResponse.FailureReason.Equals(string.Empty)) { this.logger.LogError($"Failed to get meeting details for agent. The Graph call failed: {graphMeetingDetailsResponse.FailureReason}"); return(this.StatusCode(400, new UnsuccessfulResponse { Reason = graphMeetingDetailsResponse.FailureReason })); } // Graph /calendarView endpoint returns results that are inclusive of the given startDateTime // We filter out events that are adjacent to (but not inside of) the constraint var filteredResults = graphMeetingDetailsResponse.Result .Where(meeting => meeting.MeetingTime.StartDateTime <constraints.EndDateTime && meeting.MeetingTime.EndDateTime> constraints.StartDateTime); return(this.Ok(filteredResults)); }
public void StartTimeSpanTest() { var timeBlock = new TimeBlock(_start, _duration); timeBlock.Start.Should().Be(_start); timeBlock.Duration.Should().Be(_duration); timeBlock.End.Should().Be(_end); timeBlock.HasPeriod.Should().Be.True(); timeBlock.IsAnytime.Should().Be.False(); timeBlock.IsMoment.Should().Be.False(); timeBlock.IsReadOnly.Should().Be.False(); }
public void CopyConstructorTest() { var source = new TimeBlock(_start, _start.AddHours(1), true); var copy = new TimeBlock(source); copy.Start.Should().Be(source.Start); copy.Duration.Should().Be(source.Duration); copy.End.Should().Be(source.End); copy.IsReadOnly.Should().Be.True(); copy.HasPeriod.Should().Be.True(); copy.IsAnytime.Should().Be.False(); copy.IsMoment.Should().Be.False(); }
public void EndReadOnlyTest() { var timeBlock = new TimeBlock(ClockProxy.Clock.Now.AddHours(-1), ClockProxy.Clock.Now, true); Assert.Throws <InvalidOperationException>(() => timeBlock.End = timeBlock.End.AddHours(1)); }
public static double AverageShareOfBlockRewardPerSpanFast(AverageShareOfBlockRewardDT data, TimeBlock timeBlock) { // normalize into minerHashRateAsAPercentOfTotal the MinerHashRate / NetworkHashRate using the TimeBlock of the Miner HashRate minerHashRateAsAPercentOfTotal = default;// ToDo: Fix this calculation data.MinerHashRate / data.NetworkHashRate; // normalize the BlockRewardPerSpan to the same span the Miner HashRate span //ToDo Fix this calculation // normalize the BlockRewardPerSpan to the same span the network HashRate span double normalizedBlockCreationSpan = data.AverageBlockCreationSpan.Duration.Ticks / data.NetworkHashRate.HashRateTimeSpan.Duration().Ticks; double normalizedBlockRewardPerSpan = data.BlockRewardPerBlock / (data.AverageBlockCreationSpan.Duration.Ticks * normalizedBlockCreationSpan); // The number of block rewards found, on average, within a given TimeBlock, is number of blocks in the span, times the fraction of the NetworkHashRate contributed by the miner return(normalizedBlockRewardPerSpan * (minerHashRateAsAPercentOfTotal.HashRatePerTimeSpan / data.NetworkHashRate.HashRatePerTimeSpan)); }