public string Format(Interval value) { var start = value.HasStart ? InstantPattern.Format(value.Start) : string.Empty; var end = value.HasEnd ? InstantPattern.Format(value.End) : string.Empty; return($"{start}/{end}"); }
public void Create() { var pattern = InstantPattern.Create("HH:mm:ss", Cultures.DotTimeSeparator); var text = pattern.Format(Instant.FromUtc(2000, 1, 1, 12, 34, 56)); Assert.AreEqual("12.34.56", text); }
/// <summary> /// Turn a NodaTime instant into a datetime format of rfc2822 found on page #14. /// </summary> /// <param name="instant">The NodaTime instant to be used.</param> /// <returns>A string representing a datetime in RFC2822 format.</returns> public static string ToRfc2822DateFormat(this Instant instant) { var pattern = InstantPattern.CreateWithInvariantCulture("ddd d MMM yyyy HH:mm:ss 'GMT'"); var result = pattern.Format(instant); return(result); }
public CsvReader(Context context) { Context = context; TimePattern = string.IsNullOrWhiteSpace(Context.CsvTimeFormat) ? InstantPattern.ExtendedIsoPattern : InstantPattern.CreateWithInvariantCulture(Context.CsvTimeFormat); }
public void ToTimestamp_Valid(string instantText, long expectedSeconds, int expectedNanos) { var pattern = InstantPattern.CreateWithInvariantCulture("uuuu-MM-dd'T'HH:mm:ss.fffffffff"); var instant = pattern.Parse(instantText).Value; var timestamp = instant.ToTimestamp(); Assert.AreEqual(expectedSeconds, timestamp.Seconds); Assert.AreEqual(expectedNanos, timestamp.Nanos); }
public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData) { if (text == null) { return(base.ConvertFromString(null, row, memberMapData)); } return(InstantPattern.CreateWithInvariantCulture("yyyy-MM-dd").Parse(text).Value); }
public void CreateWithCurrentCulture() { using (CultureSaver.SetCultures(Cultures.DotTimeSeparator)) { var pattern = InstantPattern.CreateWithCurrentCulture("HH:mm:ss"); var text = pattern.Format(Instant.FromUtc(2000, 1, 1, 12, 34, 56)); Assert.AreEqual("12.34.56", text); } }
public async Task <Album> GetAlbumFromAlbumLink(string albumName, string albumLink) { var albumPage = await GetAlbumPageInfo(albumLink); if (albumPage == null) { return(null); } string name; var aliases = new List <string> { albumName }; var enNames = SeparateAlbumArtistNames(albumPage.Names.En); if (albumPage.Names.Ja != null) { var jaNames = SeparateAlbumArtistNames(albumPage.Names.Ja); name = jaNames.Last(); aliases.AddRange(jaNames.SkipLast(1)); aliases.AddRange(enNames); if (albumPage.Names.Ja_Latn != null) { aliases.AddRange(SeparateAlbumArtistNames(albumPage.Names.Ja_Latn)); } } else if (albumPage.Names.Ja_Latn != null) { var jaLatnNames = SeparateAlbumArtistNames(albumPage.Names.Ja_Latn); name = jaLatnNames.Last(); aliases.AddRange(jaLatnNames.SkipLast(1)); aliases.AddRange(enNames); } else { name = enNames.Last(); aliases.AddRange(enNames.SkipLast(1)); if (albumPage.Names.Ja_Latn != null) { aliases.AddRange(SeparateAlbumArtistNames(albumPage.Names.Ja_Latn)); } } var releaseDate = albumPage.Release_Date != null ? InstantPattern.CreateWithInvariantCulture("yyyy-MM-dd").Parse(albumPage.Release_Date).Value : Instant.MinValue; var album = new Album { Title = name, Aliases = aliases.Distinct().ToArray(), ReleaseDate = releaseDate, VgmdbLink = albumPage.Link }; return(album); }
public void ToInstant_Valid(long seconds, int nanos, string expectedResult) { var pattern = InstantPattern.CreateWithInvariantCulture("uuuu-MM-dd'T'HH:mm:ss.fffffffff"); var timestamp = new Timestamp { Seconds = seconds, Nanos = nanos }; var instant = timestamp.ToInstant(); Assert.AreEqual(expectedResult, pattern.Format(instant)); }
public CsvReader(Context context) { Context = context; ValidateConfiguration(); DefaultTimeOfDay = ParseTimeOnly(Context.CsvDefaultTimeOfDay, Context.CsvTimeOnlyFormat); TimePattern = string.IsNullOrWhiteSpace(Context.CsvDateTimeFormat) ? InstantPattern.ExtendedIsoPattern : InstantPattern.CreateWithInvariantCulture(Context.CsvDateTimeFormat); }
protected CsvReaderBase(Context context) : base(context) { InstantPattern = HasZoneInfo ? null : string.IsNullOrWhiteSpace(Context.CsvDateTimeFormat) ? InstantPattern.ExtendedIso : InstantPattern.CreateWithInvariantCulture(Context.CsvDateTimeFormat); LocalDateTimePattern = HasZoneInfo ? string.IsNullOrWhiteSpace(Context.CsvDateTimeFormat) ? LocalDateTimePattern.ExtendedIso : LocalDateTimePattern.CreateWithInvariantCulture(Context.CsvDateTimeFormat) : null; var isTimeFormatUtc = (InstantPattern?.PatternText.Contains("'Z'") ?? false) || (LocalDateTimePattern?.PatternText.Contains("'Z'") ?? false); if (Context.CsvDateOnlyField != null) { isTimeFormatUtc |= Context.CsvDateOnlyFormat.Contains("Z"); } if (!isTimeFormatUtc) { return; } DefaultBias = Duration.Zero; if (!HasZoneInfo) { return; } var patterns = new[] { InstantPattern?.PatternText, LocalDateTimePattern?.PatternText, Context.CsvDateOnlyFormat } .Where(s => !string.IsNullOrWhiteSpace(s)) .ToList(); var settingMessage = Context.Timezone != null ? $"/{nameof(context.Timezone)}='{context.Timezone}'" : $"/{nameof(context.CsvTimezoneField)}={context.CsvTimezoneField}"; Log.Warn($"Ignoring the {settingMessage} value since the time-format patterns \"{string.Join("\" and \"", patterns)}\" contain zone-info."); Context.Timezone = null; Context.CsvTimezoneField = null; }
public static Instant?ParseOrNull(this InstantPattern pattern, string?s) { if (s is null) { return(null); } var parseResult = pattern.Parse(s); if (!parseResult.Success) { return(null); } return(parseResult.Value); }
public void RequestHistoricalData(int requestId, Contract contract, Instant endDate = default, HistoricalDuration?duration = null, HistoricalBarSize?barSize = null, HistoricalDataType?dataType = null, bool regularTradingHoursOnly = false, bool keepUpToDate = false, IList <Tag>?options = null) { if (contract == null) { throw new ArgumentNullException(nameof(contract)); } if (endDate == default) { endDate = Config.Clock.GetCurrentInstant(); } var m = CreateMessage().Write(RequestCode.RequestHistoricalData); if (Config.ServerVersionCurrent < ServerVersion.SyntRealtimeBats) { m.Write("6"); } m.Write(requestId, contract.ContractId, contract.Symbol, contract.SecurityType, contract.LastTradeDateOrContractMonth, contract.Strike, contract.Right, contract.Multiplier, contract.Exchange, contract.PrimaryExchange, contract.Currency, contract.LocalSymbol, contract.TradingClass, contract.IncludeExpired, InstantPattern.CreateWithInvariantCulture("yyyyMMdd HH:mm:ss").Format(endDate) + " GMT", barSize ?? HistoricalBarSize.OneHour, duration ?? HistoricalDuration.OneDay, regularTradingHoursOnly, dataType ?? HistoricalDataType.Trades, "1"); // return date as text if (contract.SecurityType == SecurityType.Bag) { m.Write(contract.ComboLegs.Count); foreach (var leg in contract.ComboLegs) { m.Write(leg.ContractId, leg.Ratio, leg.TradeAction, leg.Exchange); } } if (Config.SupportsServerVersion(ServerVersion.SyntRealtimeBats)) { m.Write(keepUpToDate); } m.Write(Tag.Combine(options)).Send(); }
public CsvReader(Context context) { Context = context; ValidateConfiguration(); DefaultTimeOfDay = ParseTimeOnly(Context.CsvDefaultTimeOfDay, Context.CsvTimeOnlyFormat); TimePattern = string.IsNullOrWhiteSpace(Context.CsvDateTimeFormat) ? InstantPattern.ExtendedIsoPattern : InstantPattern.CreateWithInvariantCulture(Context.CsvDateTimeFormat); DefaultBias = TimePattern.PatternText.Contains("'Z'") ? Duration.Zero : Duration.FromTimeSpan((Context.UtcOffset ?? Offset.FromTicks(DateTimeOffset.Now.Offset.Ticks)).ToTimeSpan()); }
public static void Main(string[] args) { long[] timestamps = { 1413685800L, 1413689400L, 1424568600L, 1424572200L, 1424575800L }; var zone = DateTimeZoneProviders.Tzdb["America/Sao_Paulo"]; var instantPattern = InstantPattern.CreateWithInvariantCulture("dd MMM yyyy HH:mm:ss"); var zonedPattern = ZonedDateTimePattern.CreateWithInvariantCulture ("dd MMM yyyy HH:mm:ss o<g> (x)", null); foreach (long ts in timestamps) { var instant = Instant.FromSecondsSinceUnixEpoch(ts); var zonedDateTime = instant.InZone(zone); Console.WriteLine("{0} UTC - {1}", instantPattern.Format(instant), zonedPattern.Format(zonedDateTime)); } }
public NodaTimeText.ParseResult <Interval> Parse(string text) { var slash = text.IndexOf('/'); if (slash == -1) { throw new InvalidNodaDataException("Expected ISO-8601-formatted interval; slash was missing."); } var startText = text.Substring(0, slash); var endText = text.Substring(slash + 1); var startInstant = default(Instant?); var endInstant = default(Instant?); if (!string.IsNullOrEmpty(startText)) { var result = Patterns.InstantPattern.Parse(startText); if (!result.Success) { return(NodaTimeText.ParseResult <Interval> .ForException(() => result.Exception)); } startInstant = result.Value; } if (!string.IsNullOrEmpty(endText)) { var result = InstantPattern.Parse(endText); if (!result.Success) { return(NodaTimeText.ParseResult <Interval> .ForException(() => result.Exception)); } endInstant = result.Value; } return(NodaTimeText.ParseResult <Interval> .ForValue(new Interval(startInstant, endInstant))); }
public void CanNotSellAnExpiredPie( string expiryDateString, string currentDateString, [Frozen(Matching.ImplementedInterfaces)] FakeClock fakeClock, [Frozen(Matching.ImplementedInterfaces)] ProductValidationService productValidationService, [Frozen(Matching.ImplementedInterfaces)] DiscountService discountService, Basket basket) { productValidationService.AddValidator(new ExpiredPieValidator(fakeClock)); LocalDate expiryDate = LocalDatePattern.CreateWithCurrentCulture("dd/MM/yyyy").Parse(expiryDateString).Value; Instant currentDate = InstantPattern.CreateWithCurrentCulture("dd/MM/yyyy").Parse(currentDateString).Value; fakeClock.Reset(currentDate); Pie pie = new Pie(default(Price), expiryDate); AddResult result = basket.Add(pie); result.Success.Should().BeFalse(); }
/// <summary> /// Serializes the <see cref="Instant"/> for SQL Server queries. /// </summary> /// <param name="instant">An instant.</param> /// <param name="decimalPlaces">Number of digits after the decimal. Must be between 0 and 7 (both included).</param> /// <returns>A SQL formatted string representation of <paramref name="instant"/>.</returns> /// <seealso cref="ToQuotedSqlString(Instant)"/> public static string ToSqlString(this Instant instant, int decimalPlaces) { if (decimalPlaces < 0 || 7 < decimalPlaces) { throw new ArgumentOutOfRangeException(nameof(decimalPlaces), "Value must be between 0 and 7 (both included)."); } if (instant.InUtc().TimeOfDay == LocalTime.Midnight) { return(PatternWithoutTime.Format(instant)); } if (decimalPlaces == 7) { return(PatternWithSevenDecimalPlaces.Format(instant)); } if (decimalPlaces == 0) { return(PatternWithNoDecimalPlaces.Format(instant)); } return(InstantPattern.CreateWithInvariantCulture(@"yyyy'-'MM'-'dd HH':'mm':'ss." + new string('F', decimalPlaces)).Format(instant)); }
protected Instant?ParseInstant(string text, Func <DateTimeZone> zoneResolver = null) { if (LocalDateTimePattern != null) { var result = LocalDateTimePattern.Parse(text); if (result.Success) { return(InstantFromLocalDateTime(result.Value, zoneResolver)); } } if (InstantPattern != null) { var result = InstantPattern.Parse(text); if (result.Success) { return(result.Value.Minus(DefaultBias)); } } return(null); }
internal override IPattern <Instant> CreatePattern() => InstantPattern.CreateWithInvariantCulture(Pattern).WithCulture(Culture);
public void ParsePatternExtendedIso() { // Use a mutable culture info to prevent caching InstantPattern.Create(InstantPattern.ExtendedIsoPattern.PatternText, MutableInvariantCulture); }