/// Returns UTC DateTime with Kind.Unspecified public static DateTime ConvertToUtcWithUncpecifiedKind(this DateTime dateTime, string tzFrom) { string tz; if (!Normalizer.TryGetValue(tzFrom.ToLowerInvariant(), out tz)) { tz = tzFrom; } //tz = tz.ToLowerInvariant(); if (tz.ToLowerInvariant() == "utc") { if (dateTime.Kind == DateTimeKind.Local) throw new ArgumentException("Cannot treat local time as Utc, please specify kind = Utc or Uncpecified"); return DateTime.SpecifyKind(dateTime, DateTimeKind.Unspecified); } var utcTimeZone = DateTimeZoneProviders.Tzdb["UTC"]; var givenTz = DateTimeZoneProviders.Tzdb[tz]; var tickWithinSecond = (int) (dateTime.Ticks%TimeSpan.TicksPerSecond); var millis = tickWithinSecond / 10000; var tickWithinMillis = tickWithinSecond % 10000; var timeToConvert = new LocalDateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, millis, tickWithinMillis ).InZoneStrictly(givenTz); ; DateTime utcTime = timeToConvert.ToDateTimeUtc(); return DateTime.SpecifyKind(utcTime, DateTimeKind.Unspecified); }
public void AddFourYearsOnLeapDay() { LocalDateTime start = new LocalDateTime(2012, 2, 29, 10, 0); LocalDateTime result = start + Period.FromYears(4); // Feb 29th is still valid in 2016 Assert.AreEqual(new LocalDateTime(2016, 2, 29, 10, 0), result); }
public void UnixEpoch() { CalendarSystem coptic = CalendarSystem.GetCopticCalendar(4); LocalDateTime unixEpochInCopticCalendar = new LocalDateTime(LocalInstant.LocalUnixEpoch, coptic); LocalDateTime expected = new LocalDateTime(1686, 4, 23, 0, 0, coptic); Assert.AreEqual(expected, unixEpochInCopticCalendar); }
public void Epoch() { LocalDateTime julianEpoch = new LocalDateTime(LocalInstant.LocalUnixEpoch, Julian); Assert.AreEqual(1969, julianEpoch.Year); Assert.AreEqual(12, julianEpoch.MonthOfYear); Assert.AreEqual(19, julianEpoch.DayOfMonth); }
public void EraProperty() { CalendarSystem calendar = CalendarSystem.Gregorian; LocalDateTime startOfEra = new LocalDateTime(1, 1, 1, 0, 0, 0, calendar); Assert.AreEqual(Era.Common, startOfEra.Era); Assert.AreEqual(Era.BeforeCommon, startOfEra.PlusTicks(-1).Era); }
public void FieldsOf_GreatAchievement() { LocalDateTime now = new LocalDateTime(new LocalInstant((TimeOfGreatAchievement - UnixEpochDateTime).Ticks), CalendarSystem.Iso); Assert.AreEqual(2009, now.Year); Assert.AreEqual(2009, now.YearOfEra); Assert.AreEqual(9, now.YearOfCentury); Assert.AreEqual(20, now.CenturyOfEra); Assert.AreEqual(2009, now.WeekYear); Assert.AreEqual(48, now.WeekOfWeekYear); Assert.AreEqual(11, now.MonthOfYear); Assert.AreEqual(27, now.DayOfMonth); Assert.AreEqual(TimeOfGreatAchievement.DayOfYear, now.DayOfYear); Assert.AreEqual(IsoDayOfWeek.Friday, now.IsoDayOfWeek); Assert.AreEqual(5, now.DayOfWeek); Assert.AreEqual(Era.Common, now.Era); Assert.AreEqual(18, now.HourOfDay); Assert.AreEqual(38, now.MinuteOfHour); Assert.AreEqual(25, now.SecondOfMinute); Assert.AreEqual((18 * 60 * 60) + (38 * 60) + 25, now.SecondOfDay); Assert.AreEqual(345, now.MillisecondOfSecond); Assert.AreEqual(345 + now.SecondOfDay * 1000, now.MillisecondOfDay); Assert.AreEqual(now.MillisecondOfDay * 10000L + 8765, now.TickOfDay); Assert.AreEqual(8765, now.TickOfMillisecond); Assert.AreEqual(3458765, now.TickOfSecond); }
public void GetOccurrenceForYear_Defaults_Epoch() { var offset = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, LocalTime.Midnight); var actual = offset.GetOccurrenceForYear(1970); var expected = new LocalDateTime(1970, 1, 1, 0, 0).ToLocalInstant(); Assert.AreEqual(expected, actual); }
public void AddMilliseconds_Arround3Days_AreEqual() { var act = TestStruct.AddMilliseconds(3 * 24 * 60 * 60 * 1003); var exp = new LocalDateTime(1988, 06, 16, 22, 23, 02, 601); Assert.AreEqual(exp, act); }
public void AddMinutes_2280_AreEqual() { var act = TestStruct.AddMinutes(2 * 24 * 60); var exp = new LocalDateTime(1988, 06, 15, 22, 10, 05, 001); Assert.AreEqual(exp, act); }
public void UnixEpoch() { CalendarSystem coptic = CalendarSystem.Coptic; LocalDateTime unixEpochInCopticCalendar = NodaConstants.UnixEpoch.InZone(DateTimeZone.Utc, coptic).LocalDateTime; LocalDateTime expected = new LocalDateTime(1686, 4, 23, 0, 0, coptic); Assert.AreEqual(expected, unixEpochInCopticCalendar); }
public void AddHours_41_AreEqual() { var act = TestStruct.AddHours(41); var exp = new LocalDateTime(1988, 06, 15, 15, 10, 05, 001); Assert.AreEqual(exp, act); }
public void AddOneYearOnLeapDay() { LocalDateTime start = new LocalDateTime(2012, 2, 29, 10, 0); LocalDateTime result = start + Period.FromYears(1); // Feb 29th becomes Feb 28th Assert.AreEqual(new LocalDateTime(2013, 2, 28, 10, 0), result); }
public Answer GetAnswer(Question question) { var cityToken = question.GetToken<CityToken>(); var dateToken = question.GetToken<DateToken>(); int? year = null; if (dateToken != null) year = dateToken.Year; DaylightSavingInformation daylightSavingInfo; if (year.HasValue) { var firstDateInTheYear = new LocalDateTime(year.Value, 1, 1, 0, 0).InZone(DateTimeZoneProviders.Tzdb[cityToken.City.Timezone], Resolvers.LenientResolver); var firstZoneIntervalInTheYear = firstDateInTheYear.GetZoneInterval(); if (firstZoneIntervalInTheYear.IsoLocalEnd.Year > 10000) { daylightSavingInfo = DaylightSavingInformation.CreateWithNoDaylightSavings(); } else { var firstDateInTheNextZoneInterval = firstDateInTheYear.Plus(firstZoneIntervalInTheYear.Duration).Plus(Duration.FromMilliseconds(1)); daylightSavingInfo = GetDaylightSavingInfo(firstDateInTheNextZoneInterval); } } else { daylightSavingInfo = GetDaylightSavingInfo(cityToken.GetCurrentTime()); } var answerText = GetFormattedDaylightSavingInfo(daylightSavingInfo, cityToken.City); return new Answer(question, true, true, answerText); }
public void FieldsOf_UnixEpoch() { // It's easiest to test this using a LocalDateTime in the ISO calendar system. // LocalDateTime just passes everything through anyway. LocalDateTime epoch = new LocalDateTime(LocalInstant.LocalUnixEpoch, CalendarSystem.Iso); Assert.AreEqual(1970, epoch.Year); Assert.AreEqual(1970, epoch.YearOfEra); Assert.AreEqual(70, epoch.YearOfCentury); Assert.AreEqual(19, epoch.CenturyOfEra); Assert.AreEqual(1970, epoch.WeekYear); Assert.AreEqual(1, epoch.WeekOfWeekYear); Assert.AreEqual(1, epoch.MonthOfYear); Assert.AreEqual(1, epoch.DayOfMonth); Assert.AreEqual(1, epoch.DayOfYear); Assert.AreEqual(IsoDayOfWeek.Thursday, epoch.IsoDayOfWeek); Assert.AreEqual(4, epoch.DayOfWeek); Assert.AreEqual(Era.Common, epoch.Era); Assert.AreEqual(0, epoch.HourOfDay); Assert.AreEqual(0, epoch.MinuteOfHour); Assert.AreEqual(0, epoch.SecondOfMinute); Assert.AreEqual(0, epoch.SecondOfDay); Assert.AreEqual(0, epoch.MillisecondOfSecond); Assert.AreEqual(0, epoch.MillisecondOfDay); Assert.AreEqual(0, epoch.TickOfDay); Assert.AreEqual(0, epoch.TickOfMillisecond); Assert.AreEqual(0, epoch.TickOfSecond); }
public void SampleDate() { CalendarSystem copticCalendar = CalendarSystem.GetCopticCalendar(4); LocalDateTime iso = new LocalDateTime(2004, 6, 9, 0, 0, 0, 0); LocalDateTime coptic = new LocalDateTime(iso.LocalInstant, copticCalendar); Assert.AreEqual(Era.AnnoMartyrm, coptic.Era); Assert.AreEqual(18, coptic.CenturyOfEra); Assert.AreEqual(20, coptic.YearOfCentury); Assert.AreEqual(1720, coptic.YearOfEra); Assert.AreEqual(1720, coptic.Year); Assert.IsFalse(copticCalendar.IsLeapYear(1720)); Assert.AreEqual(10, coptic.MonthOfYear); Assert.AreEqual(2, coptic.DayOfMonth); // TODO: Determine whether we should consider the Coptic calendar to use ISO // days of the week. Assert.AreEqual(IsoDayOfWeek.Wednesday, coptic.IsoDayOfWeek); Assert.AreEqual(9 * 30 + 2, coptic.DayOfYear); Assert.AreEqual(0, coptic.HourOfDay); Assert.AreEqual(0, coptic.MinuteOfHour); Assert.AreEqual(0, coptic.SecondOfMinute); Assert.AreEqual(0, coptic.MillisecondOfSecond); Assert.AreEqual(0, coptic.TickOfMillisecond); }
public void ComputedProperties() { LocalDateTime start = new LocalDateTime(2011, 6, 3, 19, 15); LocalDateTime end = new LocalDateTime(2011, 8, 2, 22, 45); Assert.AreEqual(start, SampleInterval.IsoLocalStart); Assert.AreEqual(end, SampleInterval.IsoLocalEnd); Assert.AreEqual(SampleEnd - SampleStart, SampleInterval.Duration); }
public void LocalDateTimeProperty() { LocalDateTime local = new LocalDateTime(2012, 6, 19, 1, 2, 3, 4, 5, CalendarSystem.Julian); Offset offset = Offset.FromHours(5); OffsetDateTime odt = new OffsetDateTime(local, offset); Assert.AreEqual(local, odt.LocalDateTime); }
public void JulianEpoch() { // Compute the Julian epoch using the Julian calendar, instead of the // Gregorian version. var localEpoch = new LocalDateTime(-4712, 1, 1, 12, 0, CalendarSystem.Julian); var epoch = localEpoch.InZoneStrictly(DateTimeZone.Utc).ToInstant(); Assert.AreEqual(epoch, NodaConstants.JulianEpoch); }
public void TimeOfDay_After1970() { LocalDateTime dateTime = new LocalDateTime(1975, 11, 8, 12, 5, 23); LocalTime expected = new LocalTime(12, 5, 23); Assert.AreEqual(expected, dateTime.TimeOfDay); Assert.AreEqual(new LocalDateTime(1970, 1, 1, 12, 5, 23), dateTime.TimeOfDay.LocalDateTime); }
internal LocalDateTime Add(LocalDateTime start, long units) { int extraDays = 0; LocalTime time = Add(start.TimeOfDay, units, ref extraDays); // Even though PlusDays optimizes for "value == 0", it's still quicker not to call it. LocalDate date = extraDays == 0 ? start.Date : start.Date.PlusDays(extraDays); return new LocalDateTime(date, time); }
public DateTime DateTimeWithOlsenZoneToUtc(DateTime dateTime, string olsenTimeZone) { var dateTimeZoneProvider = DateTimeZoneProviders.Tzdb; var dateTimeZone = dateTimeZoneProvider[olsenTimeZone]; var startTime = dateTime; var localDateTime = new LocalDateTime(startTime.Year, startTime.Month, startTime.Day, startTime.Hour, startTime.Minute); return dateTimeZone.AtLeniently(localDateTime).ToDateTimeUtc(); }
public Zinsfestschreibung(LocalDateTime festschreibung, LocalDateTime auslauf, double zinssatz) : this() { this.ZeitpunktFestschreibung = festschreibung; this.ZeitpunktAuslauf = auslauf; this.Zinssatz = zinssatz; ////this.ZeitraumFestschreibungZinstage = (int)(Period.Between(this.ZeitpunktFestschreibung, this.ZeitpunktAuslauf).Days); }
public void PlusDays_Simple() { LocalDateTime start = new LocalDateTime(2011, 1, 15, 12, 15, 8); LocalDateTime expected = new LocalDateTime(2011, 1, 23, 12, 15, 8); Assert.AreEqual(expected, start.PlusDays(8)); expected = new LocalDateTime(2011, 1, 7, 12, 15, 8); Assert.AreEqual(expected, start.PlusDays(-8)); }
public void instant_as_local_time() { // "America/New_York" var est = DateTimeZoneProviders.Tzdb["America/New_York"]; _output.WriteLine(est.ToJson()); var localDateTime = new LocalDateTime(2016, 1, 21, 20, 6); _output.WriteLine(localDateTime.ToString()); var estDateTime = est.AtStrictly(localDateTime); Assert.Equal("2016-01-21T20:06:00 America/New_York (-05)", estDateTime.ToString()); }
public void ConstructLocalInstant_WithAllFields() { LocalInstant localAchievement = new LocalDateTime(2009, 11, 27, 18, 38, 25, 345, 8765).ToLocalInstant(); long bclTicks = (TimeOfGreatAchievement - UnixEpochDateTime).Ticks; int bclDays = (int) (bclTicks / NodaConstants.TicksPerDay); long bclTickOfDay = bclTicks % NodaConstants.TicksPerDay; Assert.AreEqual(bclDays, localAchievement.DaysSinceEpoch); Assert.AreEqual(bclTickOfDay, localAchievement.NanosecondOfDay / NodaConstants.NanosecondsPerTick); }
public void ToInstant() { Instant instant = Instant.FromUtc(2012, 6, 25, 16, 5, 20); LocalDateTime local = new LocalDateTime(2012, 6, 25, 21, 35, 20); Offset offset = Offset.FromHoursAndMinutes(5, 30); OffsetDateTime odt = new OffsetDateTime(local, offset); Assert.AreEqual(instant, odt.ToInstant()); }
public void WithCalendar() { LocalDateTime isoEpoch = new LocalDateTime(1970, 1, 1, 0, 0, 0); LocalDateTime julianEpoch = isoEpoch.WithCalendar(CalendarSystem.GetJulianCalendar(4)); Assert.AreEqual(1969, julianEpoch.Year); Assert.AreEqual(12, julianEpoch.MonthOfYear); Assert.AreEqual(19, julianEpoch.DayOfMonth); Assert.AreEqual(isoEpoch.TimeOfDay, julianEpoch.TimeOfDay); }
public void PlusYear_LeapToNonLeap() { LocalDateTime start = new LocalDateTime(2012, 2, 29, 12, 15, 8); LocalDateTime expected = new LocalDateTime(2013, 2, 28, 12, 15, 8); Assert.AreEqual(expected, start.PlusYears(1)); expected = new LocalDateTime(2011, 2, 28, 12, 15, 8); Assert.AreEqual(expected, start.PlusYears(-1)); }
public void PlusYear_Simple() { LocalDateTime start = new LocalDateTime(2011, 6, 26, 12, 15, 8); LocalDateTime expected = new LocalDateTime(2016, 6, 26, 12, 15, 8); Assert.AreEqual(expected, start.PlusYears(5)); expected = new LocalDateTime(2006, 6, 26, 12, 15, 8); Assert.AreEqual(expected, start.PlusYears(-5)); }
public void ToDateTimeUnspecified() { LocalDateTime zoned = new LocalDateTime(2011, 3, 5, 1, 0, 0); DateTime expected = new DateTime(2011, 3, 5, 1, 0, 0, DateTimeKind.Unspecified); DateTime actual = zoned.ToDateTimeUnspecified(); Assert.AreEqual(expected, actual); // Kind isn't checked by Equals... Assert.AreEqual(DateTimeKind.Unspecified, actual.Kind); }
public LocalDateTime FromDateTime() => LocalDateTime.FromDateTime(SampleDateTime);
public void XmlSerialization_Iso() { var value = new LocalDateTime(2013, 4, 12, 17, 53, 23).PlusNanoseconds(123456789); TestHelper.AssertXmlRoundtrip(value, "<value>2013-04-12T17:53:23.123456789</value>"); }
public void InZoneStrictly_ThrowsWhenSkipped() { var local = new LocalDateTime(2009, 3, 8, 2, 30, 0); Assert.Throws <SkippedTimeException>(() => local.InZoneStrictly(Pacific)); }
/// <summary> /// Populate with values based on the specified array /// of value types, repeating the types in cycle. /// </summary> private void PopulateValues(VariantType[] valueTypes, VariantMatrix result) { // Initial values to populate the data int stringValueAsInt = 0; bool boolValue = false; int intValue = 0; long longValue = 0; double doubleValue = 0.5; LocalDate localDateValue = new LocalDate(2003, 5, 1); LocalTime localTimeValue = new LocalTime(10, 15, 30); LocalMinute localMinuteValue = new LocalMinute(10, 15); LocalDateTime localDateTimeValue = new LocalDateTime(2003, 5, 1, 10, 15, 0); Instant instantValue = new LocalDateTime(2003, 5, 1, 10, 15, 0).ToInstant(DateTimeZone.Utc); int valueTypeCount = valueTypes.Length; for (int rowIndex = 0; rowIndex < result.RowCount; rowIndex++) { for (int colIndex = 0; colIndex < result.ColCount; colIndex++) { // Repeat value types in cycle var valueType = valueTypes[colIndex % valueTypeCount]; switch (valueType) { case VariantType.String: result[rowIndex, colIndex] = $"Str{stringValueAsInt++}"; break; case VariantType.Double: result[rowIndex, colIndex] = doubleValue++; break; case VariantType.Bool: result[rowIndex, colIndex] = boolValue; boolValue = !boolValue; break; case VariantType.Int: result[rowIndex, colIndex] = intValue++; break; case VariantType.Long: result[rowIndex, colIndex] = longValue++; break; case VariantType.LocalDate: result[rowIndex, colIndex] = localDateValue; localDateValue = localDateValue.PlusDays(1); break; case VariantType.LocalTime: result[rowIndex, colIndex] = localTimeValue; localTimeValue = localTimeValue.PlusHours(1); break; case VariantType.LocalMinute: result[rowIndex, colIndex] = localMinuteValue; localMinuteValue = localMinuteValue.ToLocalTime().PlusHours(1).ToLocalMinute(); break; case VariantType.LocalDateTime: result[rowIndex, colIndex] = localDateTimeValue; localDateTimeValue = localDateTimeValue.PlusDays(2).PlusHours(2); break; case VariantType.Instant: result[rowIndex, colIndex] = instantValue; instantValue = instantValue; // TODO Fix, uses previous value break; default: throw new Exception($"Value type {valueType} cannot be stored in VariantMatrix."); } } } }
public static DateTime ToDateTime(this LocalDateTime dt) { return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, dt.Millisecond)); }
public LocalDateTime FromDateTime_WithCalendar() => LocalDateTime.FromDateTime(SampleDateTime, CalendarSystem.Julian);
public static DateTime Resolve(LocalDateTime value) { return(value.ToDateTimeUnspecified()); }
/// <summary> /// Updates a finish's price table entry /// </summary> /// <param name="modelView">model view containing updatable information</param> /// <returns>True if the update is successful</returns> public static GetMaterialFinishPriceModelView update(UpdateFinishPriceTableEntryModelView modelView, IHttpClientFactory clientFactory) { string defaultCurrency = CurrencyPerAreaConversionService.getBaseCurrency(); string defaultArea = CurrencyPerAreaConversionService.getBaseArea(); MaterialRepository materialRepository = PersistenceContext.repositories().createMaterialRepository(); long materialId = modelView.entityId; bool performedAtLeastOneUpdate = false; Material material = materialRepository.find(materialId); if (material == null) { throw new ResourceNotFoundException(MATERIAL_NOT_FOUND); } foreach (Finish finish in material.Finishes) { if (finish.Id == modelView.finishId) { FinishPriceTableRepository finishPriceTableRepository = PersistenceContext.repositories().createFinishPriceTableRepository(); long finishPriceTableEntryId = modelView.tableEntryId; FinishPriceTableEntry tableEntryToUpdate = finishPriceTableRepository.find(finishPriceTableEntryId); if (tableEntryToUpdate == null) { throw new ResourceNotFoundException(ENTRY_NOT_FOUND); } if (tableEntryToUpdate.entity.Id != modelView.finishId) { throw new InvalidOperationException(ENTRY_DOESNT_BELONG_TO_FINISH); } LocalDateTime currentTime = NodaTime.LocalDateTime.FromDateTime(SystemClock.Instance.GetCurrentInstant().ToDateTimeUtc()); if (modelView.priceTableEntry.startingDate != null && LocalDateTimePattern.GeneralIso.Format(tableEntryToUpdate.timePeriod.startingDate).Equals(modelView.priceTableEntry.startingDate)) { if (tableEntryToUpdate.timePeriod.startingDate.CompareTo(currentTime) < 0) { throw new InvalidOperationException(PAST_DATE); } } if (modelView.priceTableEntry.endingDate != null && LocalDateTimePattern.GeneralIso.Format(tableEntryToUpdate.timePeriod.endingDate).Equals(modelView.priceTableEntry.endingDate)) { if (tableEntryToUpdate.timePeriod.endingDate.CompareTo(currentTime) < 0) { throw new InvalidOperationException(PAST_DATE); } } if (modelView.priceTableEntry.price != null) { CurrenciesService.checkCurrencySupport(modelView.priceTableEntry.price.currency); AreasService.checkAreaSupport(modelView.priceTableEntry.price.area); Price newPrice = null; try { if (defaultCurrency.Equals(modelView.priceTableEntry.price.currency) && defaultArea.Equals(modelView.priceTableEntry.price.area)) { newPrice = Price.valueOf(modelView.priceTableEntry.price.value); } else { Task <double> convertedValueTask = new CurrencyPerAreaConversionService(clientFactory) .convertCurrencyPerAreaToDefaultCurrencyPerArea( modelView.priceTableEntry.price.currency, modelView.priceTableEntry.price.area, modelView.priceTableEntry.price.value); convertedValueTask.Wait(); double convertedValue = convertedValueTask.Result; newPrice = Price.valueOf(convertedValue); } } catch (HttpRequestException) { newPrice = Price.valueOf(modelView.priceTableEntry.price.value); } tableEntryToUpdate.changePrice(newPrice); performedAtLeastOneUpdate = true; } if (modelView.priceTableEntry.endingDate != null) { LocalDateTime newEndingDate; try { string newEndingDateAsString = modelView.priceTableEntry.endingDate; newEndingDate = LocalDateTimePattern.GeneralIso.Parse(newEndingDateAsString).GetValueOrThrow(); tableEntryToUpdate.changeTimePeriod(TimePeriod.valueOf(tableEntryToUpdate.timePeriod.startingDate, newEndingDate)); performedAtLeastOneUpdate = true; } catch (UnparsableValueException) { throw new UnparsableValueException(DATES_WRONG_FORMAT + LocalDateTimePattern.GeneralIso.PatternText); } } if (modelView.priceTableEntry.startingDate != null) { LocalDateTime newStartingDate; try { string newStartingDateAsString = modelView.priceTableEntry.startingDate; newStartingDate = LocalDateTimePattern.GeneralIso.Parse(newStartingDateAsString).GetValueOrThrow(); tableEntryToUpdate.changeTimePeriod(TimePeriod.valueOf(newStartingDate, tableEntryToUpdate.timePeriod.endingDate)); performedAtLeastOneUpdate = true; } catch (UnparsableValueException) { throw new UnparsableValueException(DATES_WRONG_FORMAT + LocalDateTimePattern.GeneralIso.PatternText); } } if (performedAtLeastOneUpdate) { FinishPriceTableEntry updatedTableEntry = finishPriceTableRepository.update(tableEntryToUpdate); if (updatedTableEntry == null) { throw new InvalidOperationException(UPDATE_NOT_SUCCESSFUL); } GetMaterialFinishPriceModelView updatedTableEntryModelView = new GetMaterialFinishPriceModelView(); updatedTableEntryModelView.id = updatedTableEntry.Id; updatedTableEntryModelView.finishId = updatedTableEntry.entity.Id; updatedTableEntryModelView.value = updatedTableEntry.price.value; updatedTableEntryModelView.currency = defaultCurrency; updatedTableEntryModelView.area = defaultArea; updatedTableEntryModelView.startingDate = LocalDateTimePattern.GeneralIso.Format(updatedTableEntry.timePeriod.startingDate); updatedTableEntryModelView.endingDate = LocalDateTimePattern.GeneralIso.Format(updatedTableEntry.timePeriod.endingDate); return(updatedTableEntryModelView); } } } throw new ResourceNotFoundException(FINISH_NOT_FOUND_OR_DOESNT_BELONG_TO_MATERIAL); }
/// <summary> /// Calculate the schedule working time between the specified dates and times /// </summary> /// <param name="from">Starting date and time</param> /// <param name="to">Ending date and time</param> /// <returns>Duration</returns> public Duration CalculateWorkingTime(LocalDateTime from, LocalDateTime to) { if (from.CompareTo(to) > 0) { string msg = string.Format(WorkSchedule.GetMessage("end.earlier.than.start"), to, from); throw new Exception(msg); } Duration sum = Duration.Zero; LocalDate thisDate = from.Date; LocalTime thisTime = from.TimeOfDay; LocalDate toDate = to.Date; LocalTime toTime = to.TimeOfDay; int dayCount = Rotation.GetDayCount(); // get the working shift from yesterday Shift lastShift = null; LocalDate yesterday = thisDate.PlusDays(-1); ShiftInstance yesterdayInstance = GetShiftInstanceForDay(yesterday); if (yesterdayInstance != null) { lastShift = yesterdayInstance.Shift; } // step through each day until done while (thisDate.CompareTo(toDate) < 1) { if (lastShift != null && lastShift.SpansMidnight()) { // check for days in the middle of the time period bool lastDay = thisDate.CompareTo(toDate) == 0 ? true : false; if (!lastDay || (lastDay && !toTime.Equals(LocalTime.Midnight))) { // add time after midnight in this day int afterMidnightSecond = TimePeriod.SecondOfDay(lastShift.GetEnd()); int fromSecond = TimePeriod.SecondOfDay(thisTime); if (afterMidnightSecond > fromSecond) { Duration seconds = Duration.FromSeconds(afterMidnightSecond - fromSecond); sum = sum.Plus(seconds); } } } // today's shift ShiftInstance instance = GetShiftInstanceForDay(thisDate); Duration duration; if (instance != null) { lastShift = instance.Shift; // check for last date if (thisDate.CompareTo(toDate) == 0) { duration = lastShift.CalculateWorkingTime(thisTime, toTime, true); } else { duration = lastShift.CalculateWorkingTime(thisTime, LocalTime.MaxValue, true); } sum = sum.Plus(duration); } else { lastShift = null; } int n = 1; if (GetDayInRotation(thisDate) == dayCount) { // move ahead by the rotation count if possible LocalDate rotationEndDate = thisDate.PlusDays(dayCount); if (rotationEndDate.CompareTo(toDate) < 0) { n = dayCount; sum = sum.Plus(Rotation.GetWorkingTime()); } } // move ahead n days starting at midnight thisDate = thisDate.PlusDays(n); thisTime = LocalTime.Midnight; } // end day loop return(sum); }
protected override OffsetDateTime Unwrap(LocalDateTime property1Value, Offset property2Value) => new OffsetDateTime(property1Value, property2Value);
public async Task OnGet([FromQuery] int?year, [FromQuery] int?month) { if (year.HasValue && month.HasValue) { SetMonth(new YearMonth(year.Value, month.Value)); } else { SetMonth(TzdbDateTimeZoneSource.Default.ForId("Asia/Tokyo").AtStrictly(LocalDateTime.FromDateTime(DateTime.UtcNow)).Date.ToYearMonth()); } Appointments = await _service.SearchAppointmentsByYearMonthAsync(Month); }
private ZonedDateTime BuildZonedDateTime(ZoneInterval interval) => new ZonedDateTime(LocalDateTime.WithOffset(interval.WallOffset), Zone);
public static bool LocalDateTimeConverter(string name, LocalDateTime value, QueryValueConvertionType type, out string strValue) { strValue = value.ToString(NodaUtil.LocalDateTime.FullIsoPattern.PatternText, null); return(true); }
public void ShouldCreateDateTimeWithDateTimeComponents() { var cypherDateTime = new LocalDateTime(1947, 12, 17, 23, 49, 54); cypherDateTime.ToDateTime().Should().Be(new DateTime(1947, 12, 17, 23, 49, 54)); }
/// <summary> /// Override for efficiency: we know we'll always have an unambiguous mapping for any LocalDateTime. /// </summary> public override ZoneLocalMapping MapLocal(LocalDateTime localDateTime) => new ZoneLocalMapping(this, localDateTime, interval, interval, 1);
public void ShouldCreateDateTimeWithDateTimeComponentsWithNanoseconds() { var cypherDateTime = new LocalDateTime(1947, 12, 17, 23, 49, 54, 192794500); cypherDateTime.ToDateTime().Should().Be(new DateTime(1947, 12, 17, 23, 49, 54).AddTicks(1927945)); }
public bool Contains(LocalDateTime LocalDateTime) => LocalDateTime >= start && LocalDateTime < end;
internal GeneralLedgerEntry(GeneralLedgerEntryIdentifier identifier, GeneralLedgerEntryNumber number, AccountingPeriod accountingPeriod, LocalDateTime createdOn) : this() { if (!accountingPeriod.Contains(createdOn.Date)) { throw new GeneralLedgerEntryNotInPeriodException(number, createdOn, accountingPeriod); } Apply(new GeneralLedgerEntryCreated { GeneralLedgerEntryId = identifier.ToGuid(), Number = number.ToString(), CreatedOn = Time.Format.LocalDateTime(createdOn), Period = accountingPeriod.ToString() }); }
public void InZoneStrictly_ThrowsWhenAmbiguous() { var local = new LocalDateTime(2009, 11, 1, 1, 30, 0); Assert.Throws <AmbiguousTimeException>(() => local.InZoneStrictly(Pacific)); }
/// <summary> /// Gets last day of week /// </summary> /// <param name="ldt"></param> /// <returns></returns> public static LocalDateTime LastDayOfWeek(this LocalDateTime ldt) => ldt.FirstDayOfWeek().AddDays(6);
public void DefaultConstructor() { var actual = new LocalDateTime(); Assert.AreEqual(new LocalDateTime(1, 1, 1, 0, 0), actual); }
private bool DayMatches(LocalDateTime aDate) => aDate.DayOfWeek == _dayIndex;
public void XmlSerialization_NonIso() { var value = new LocalDateTime(2013, 4, 12, 17, 53, 23, CalendarSystem.Julian); TestHelper.AssertXmlRoundtrip(value, "<value calendar=\"Julian\">2013-04-12T17:53:23</value>"); }
public void Timestamp(LocalDateTime localDateTime) { using (var conn = OpenConnection()) { var instant = localDateTime.InUtc().ToInstant(); var minTimestampPostgres = Instant.FromUtc(-4713, 12, 31, 00, 00, 00); var maxTimestampPostgres = Instant.MaxValue; conn.ExecuteNonQuery("CREATE TEMP TABLE data (d1 TIMESTAMP, d2 TIMESTAMP, d3 TIMESTAMP, d4 TIMESTAMP, d5 TIMESTAMP, d6 TIMESTAMP, d7 TIMESTAMP)"); using (var cmd = new NpgsqlCommand("INSERT INTO data VALUES (@p1, @p2, @p3, @p4, @p5, @p6, @p7)", conn)) { cmd.Parameters.Add(new NpgsqlParameter("p1", NpgsqlDbType.Timestamp) { Value = instant }); cmd.Parameters.Add(new NpgsqlParameter("p2", DbType.DateTime) { Value = instant }); cmd.Parameters.Add(new NpgsqlParameter("p3", DbType.DateTime2) { Value = instant }); cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p4", Value = instant }); cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p5", Value = localDateTime }); cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p6", Value = minTimestampPostgres }); cmd.Parameters.Add(new NpgsqlParameter { ParameterName = "p7", Value = maxTimestampPostgres }); cmd.ExecuteNonQuery(); } // Make sure the values inserted are the good ones, textually using (var cmd = new NpgsqlCommand("SELECT d1::TEXT, d2::TEXT, d3::TEXT, d4::TEXT, d5::TEXT FROM data", conn)) using (var reader = cmd.ExecuteReader()) { reader.Read(); for (var i = 0; i < reader.FieldCount; i++) { Assert.That(reader.GetValue(i), Is.EqualTo(instant.ToString("yyyy'-'MM'-'dd' 'HH':'mm':'ss'.'FFFFFF", CultureInfo.InvariantCulture))); } } using (var cmd = new NpgsqlCommand("SELECT d6::TEXT, d7::TEXT FROM data", conn)) using (var reader = cmd.ExecuteReader()) { reader.Read(); Assert.That(reader.GetValue(0), Is.EqualTo("4714-12-31 00:00:00 BC")); Assert.That(reader.GetValue(1), Is.EqualTo(maxTimestampPostgres.ToString("yyyy'-'MM'-'dd' 'HH':'mm':'ss'.'FFFFFF", CultureInfo.InvariantCulture))); } using (var cmd = new NpgsqlCommand("SELECT d1, d2, d3, d4, d5 FROM data", conn)) using (var reader = cmd.ExecuteReader()) { reader.Read(); for (var i = 0; i < reader.FieldCount; i++) { Assert.That(reader.GetFieldType(i), Is.EqualTo(typeof(Instant))); Assert.That(reader.GetFieldValue <Instant>(i), Is.EqualTo(instant)); Assert.That(reader.GetValue(i), Is.EqualTo(instant)); Assert.That(reader.GetFieldValue <LocalDateTime>(i), Is.EqualTo(localDateTime)); Assert.That(() => reader.GetFieldValue <ZonedDateTime>(i), Throws.TypeOf <InvalidCastException>()); Assert.That(() => reader.GetDateTime(i), Throws.TypeOf <InvalidCastException>()); Assert.That(() => reader.GetDate(i), Throws.TypeOf <InvalidCastException>()); } } } }
internal InstantPatternParser(Instant templateValue) { localTemplateValue = templateValue.InUtc().LocalDateTime; }
public static string LocalDateTime(LocalDateTime value) => LocalDateTimePattern.Format(value);
public override bool Includes(LocalDateTime aDate) => DayMatches(aDate);
public void LocalDateTimeConverter_SerializeNonIso_Throws() { var localDateTime = new LocalDateTime(2012, 1, 2, 3, 4, 5, CalendarSystem.Coptic); Assert.Throws <ArgumentException>(() => this.AssertCsvSerialization(localDateTime, null, NodatimeConverters.LocalDateTimeConverter)); }
internal static Personal ToPersonal(this Patient patient) { var personal = patient.ToThingBase <Personal>(); var hasValue = false; var personalExtension = patient.GetExtension(HealthVaultExtensions.PatientPersonal); if (personalExtension != null) { personal.BloodType = personalExtension.GetExtensionValue <CodeableConcept>(HealthVaultExtensions.PatientBloodType)?.ToCodableValue(); personal.Ethnicity = personalExtension.GetExtensionValue <CodeableConcept>(HealthVaultExtensions.PatientEthnicity)?.ToCodableValue(); personal.HighestEducationLevel = personalExtension.GetExtensionValue <CodeableConcept>(HealthVaultExtensions.PatientHighestEducationLevel)?.ToCodableValue(); personal.IsDisabled = personalExtension.GetBoolExtension(HealthVaultExtensions.PatientIsDisabled); personal.MaritalStatus = personalExtension.GetExtensionValue <CodeableConcept>(HealthVaultExtensions.PatientMaritalStatus)?.ToCodableValue(); personal.IsVeteran = personalExtension.GetBoolExtension(HealthVaultExtensions.PatientIsVeteran); personal.OrganDonor = personalExtension.GetStringExtension(HealthVaultExtensions.PatientOrganDonor); personal.EmploymentStatus = personalExtension.GetStringExtension(HealthVaultExtensions.PatientEmploymentStatus); personal.Religion = personalExtension.GetExtensionValue <CodeableConcept>(HealthVaultExtensions.PatientReligion)?.ToCodableValue(); personal.SocialSecurityNumber = patient.Identifier.FirstOrDefault(x => x.System == Constants.FhirExtensions.SSN)?.Value; if (personal.BloodType != null || personal.Ethnicity != null || personal.HighestEducationLevel != null || personal.IsDisabled != null || personal.MaritalStatus != null || personal.IsVeteran != null || !string.IsNullOrEmpty(personal.OrganDonor) || !string.IsNullOrEmpty(personal.EmploymentStatus) || personal.Religion != null || personal.SocialSecurityNumber != null) { hasValue = true; } } if (patient.BirthDateElement != null) { hasValue = true; personal.BirthDate = new HealthServiceDateTime(LocalDateTime.FromDateTime(patient.BirthDateElement.ToDateTime().Value)) { Time = patient.BirthDateElement.GetExtensionValue <Time>(HealthVaultExtensions.PatientBirthTime)?.ToAppoximateTime() }; } if (patient.Deceased != null) { hasValue = true; switch (patient.Deceased) { case FhirBoolean b: personal.IsDeceased = b.Value; break; case FhirDateTime d: personal.IsDeceased = true; var dt = d.ToDateTimeOffset(); personal.DateOfDeath = new ApproximateDateTime( new ApproximateDate(dt.Year, dt.Month, dt.Day), new ApproximateTime(dt.Hour, dt.Minute, dt.Second, dt.Millisecond)); break; } } if (!patient.Name.IsNullOrEmpty()) { hasValue = true; var patientName = patient.Name.First(); // Take the first name available personal.Name = patientName.ToHealthVault(); } return(hasValue ? personal : null); }
public void Between_LocalDateTime_SameValue() { LocalDateTime start = new LocalDateTime(2014, 1, 1, 16, 0, 0); Assert.AreSame(Period.Zero, Period.Between(start, start)); }