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);
}
