public ChangeFeedController(IClock clock)
{
_clock = clock ?? throw new ArgumentNullException(nameof(clock));
_localTimeZone = DateTimeZoneProviders.Tzdb["Europe/Brussels"];
_localMonthPattern = LocalDatePattern.Create("MMM", new CultureInfo("nl-BE"));
_localTimeOfDayPattern = LocalTimePattern.CreateWithInvariantCulture("HH':'mm");
}
public static LocalTime ParseIsoHhmmssToLocalTimeOrThrow(this string x)
{
return(LocalTimePattern
.CreateWithInvariantCulture("HH':'mm':'ss")
.Parse(x)
.GetValueOrThrow());
}
public async Task <IActionResult> OnPost([FromQuery] int year, [FromQuery] int month, [FromQuery] int day, [FromQuery] string id)
{
if (!ModelState.IsValid)
{
ErrorMessage = "入力に誤りがあります。";
return(await PageResult(year, month, day, id));
}
var startTime = LocalTimePattern.Create("HH:mm", CultureInfo.CurrentCulture).Parse(StartTime !);
if (!startTime.Success)
{
ErrorMessage = "入力に誤りがあります。";
return(await PageResult(year, month, day, id));
}
var date = new LocalDate(year, month, day);
var result = await _service.UpdateAppointmentSlotAsync(id, date.At(startTime.Value), Period.FromMinutes(DurationMinutes !.Value), CountOfSlot !.Value);
if (!result.Succeeded)
{
ErrorMessage = result.ErrorMessage;
return(await PageResult(year, month, day, id));
}
return(RedirectToPage("SlotDetails", new { year, month, day, id }));
}
public static bool ParseTime(this string text, DateTimeZone zone, string cultureTab, bool withoutDaylightSaving, Instant givenDate, bool longFormat, out Instant result)
{
var rc = false;
result = InstantError;
if ((zone != null) && (String.IsNullOrEmpty(cultureTab) == false))
{
try
{
var culture = MxCultureInfo.Instance.GetCultureInfo(cultureTab);
if (culture != null)
{
var parseResult = LocalTimePattern.Create(MxCultureInfo.GetFormatSpecifier(MxCultureInfo.FormatType.Time, longFormat), MxCultureInfo.Instance.GetCultureInfo(cultureTab)).Parse(text);
if (parseResult.Success)
{
var localDate = givenDate.InZone(zone).LocalDateTime.Date;
var instant = parseResult.Value.On(localDate).InZoneStrictly(zone).ToInstant();
var local = instant.InZone(zone).LocalDateTime;
if (withoutDaylightSaving && zone.IsDaylightSavingsTime(instant))
{
local = local.PlusSeconds(zone.GetZoneInterval(instant).Savings.Seconds);
}
result = local.InZoneStrictly(zone).ToInstant();
rc = true;
}
}
}
catch (Exception)
{
//ignore
}
}
return(rc);
}
public static bool ParseProperty(Type type, string value, [NotNullWhen(returnValue: true)] out object?parsedValue)
{
if (type == typeof(DateTime) || type == typeof(DateTime?))
{
parsedValue = DateTime.Parse(value);
return(true);
}
if (type == typeof(ZonedDateTime) || type == typeof(ZonedDateTime?))
{
parsedValue = LocalDateTimePattern.CreateWithInvariantCulture(DATETIME_PATTERN).Parse(value).GetValueOrThrow().InUtc();
return(true);
}
if (type == typeof(LocalDateTime) || type == typeof(LocalDateTime?))
{
parsedValue = LocalDateTimePattern.CreateWithInvariantCulture(DATETIME_PATTERN).Parse(value).GetValueOrThrow();
return(true);
}
if (type == typeof(LocalDate) || type == typeof(LocalDate?))
{
parsedValue = LocalDatePattern.CreateWithInvariantCulture(DATE_PATTERN).Parse(value).GetValueOrThrow();
return(true);
}
if (type == typeof(LocalTime) || type == typeof(LocalTime?))
{
parsedValue = LocalTimePattern.CreateWithInvariantCulture(TIME_PATTERN).Parse(value).GetValueOrThrow();
return(true);
}
parsedValue = null;
return(false);
}
public EventSchedule(Event @event, int intMinutesWeekday, int intMinutesWeekend, string strMondayStart, string strTuesdayStart, string strWednesdayStart, string strThursdayStart, string strFridayStart, string strSaturdayStart, string strSundayStart)
{
Event = @event;
PeriodBuilder periodBuilderWeekday = new PeriodBuilder
{
Minutes = intMinutesWeekday
};
PeriodBuilder periodBuilderWeekend = new PeriodBuilder
{
Minutes = intMinutesWeekend
};
PerWeekdayDuration = periodBuilderWeekday.Build();
PerWeekendDuration = periodBuilderWeekend.Build();
var culture = (CultureInfo)CultureInfo.InvariantCulture.Clone();
var pattern = LocalTimePattern.Create("h:mmtt", culture);
TmeMondayStart = pattern.Parse(strMondayStart).Value;
TmeTuesdayStart = pattern.Parse(strTuesdayStart).Value;
TmeWednesdayStart = pattern.Parse(strWednesdayStart).Value;
TmeThursdayStart = pattern.Parse(strThursdayStart).Value;
TmeFridayStart = pattern.Parse(strFridayStart).Value;
TmeSaturdayStart = pattern.Parse(strSaturdayStart).Value;
TmeSundayStart = pattern.Parse(strSundayStart).Value;
}
public void WithTemplateValue_PropertyFetch()
{
LocalTime newValue = new LocalTime(1, 23, 45);
var pattern = LocalTimePattern.CreateWithInvariantCulture("HH").WithTemplateValue(newValue);
Assert.AreEqual(newValue, pattern.TemplateValue);
}
private static JsonSerializerSettings JsonSettings()
{
var settings = new JsonSerializerSettings();
var pattern = new NodaPatternConverter <LocalTime>(LocalTimePattern.CreateWithInvariantCulture("HH':'mm"));
settings.Converters.Add(pattern);
return(settings);
}
public void CreateWithCurrentCulture()
{
using (CultureSaver.SetCultures(Cultures.DotTimeSeparator))
{
var pattern = LocalTimePattern.CreateWithCurrentCulture("HH:mm");
var text = pattern.Format(new LocalTime(13, 45));
Assert.AreEqual("13.45", text);
}
}
public void ToLocalTime_Valid(int hours, int minutes, int seconds, int nanos, string expectedResult)
{
var pattern = LocalTimePattern.CreateWithInvariantCulture("HH:mm:ss.fffffffff");
var timeOfDay = new TimeOfDay {
Hours = hours, Minutes = minutes, Seconds = seconds, Nanos = nanos
};
var localTime = timeOfDay.ToLocalTime();
Assert.AreEqual(expectedResult, pattern.Format(localTime));
}
public void ToTimeOfDay_Valid(string localTimeText, int expectedHours, int expectedMinutes, int expectedSeconds, int expectedNanos)
{
var pattern = LocalTimePattern.CreateWithInvariantCulture("HH:mm:ss.fffffffff");
var localTime = pattern.Parse(localTimeText).Value;
var timeOfDay = localTime.ToTimeOfDay();
Assert.AreEqual(expectedHours, timeOfDay.Hours);
Assert.AreEqual(expectedMinutes, timeOfDay.Minutes);
Assert.AreEqual(expectedSeconds, timeOfDay.Seconds);
Assert.AreEqual(expectedNanos, timeOfDay.Nanos);
}
static void Main()
{
var culture = (CultureInfo)CultureInfo.InvariantCulture.Clone();
culture.DateTimeFormat.AMDesignator = "a.m.";
culture.DateTimeFormat.PMDesignator = "p.m.";
string text = "1:15 P.M.";
var pattern = LocalTimePattern.Create("h:mm tt", culture);
var value = pattern.Parse(text).Value;
Console.WriteLine(value);
}
private void AssertBclNodaEquality(CultureInfo culture, string patternText)
{
// On Mono, some general patterns include an offset at the end.
// https://github.com/nodatime/nodatime/issues/98
// For the moment, ignore them.
// TODO(V1.2): Work out what to do in such cases...
if (patternText.EndsWith("z"))
{
return;
}
var pattern = LocalTimePattern.Create(patternText, culture);
Assert.AreEqual(SampleDateTime.ToString(patternText, culture), pattern.Format(SampleLocalTime));
}
public async Task <IActionResult> OnGet([FromQuery] int year, [FromQuery] int month, [FromQuery] int day, [FromQuery] string id)
{
if (!ModelState.IsValid)
{
return(RedirectToPage("Index", new { year, month, day }));
}
var page = await PageResult(year, month, day, id);
StartTime = LocalTimePattern.Create("HH:mm", CultureInfo.CurrentCulture).Format(Slot !.From.TimeOfDay);
DurationMinutes = (int)Slot !.Duration.ToDuration().TotalMinutes;
CountOfSlot = Slot !.CountOfSlot;
return(page);
}
public TimeFormatSpecification(string format)
{
if (format == null)
{
throw new ArgumentNullException(nameof(format));
}
_hasOffset = HasOffset(format);
if (_hasOffset)
{
_offsetPattern = OffsetTimePattern.CreateWithInvariantCulture(GetNodaTimePattern(format));
}
else
{
_localPattern = LocalTimePattern.CreateWithInvariantCulture(GetNodaTimePattern(format));
}
}
/// <summary>
///
/// </summary>
/// <param name="time"></param>
/// <returns></returns>
public static LocalTime Parse(string time)
{
try
{
var timePattern = LocalTimePattern.CreateWithInvariantCulture("h:mmtt");
var parseResult = timePattern.Parse(time);
if (parseResult.Success)
{
return(parseResult.Value);
}
throw new InvalidOperationException("Time is in incorrect format (suggested:\"h:mmtt\" or 5:30PM)");
}
catch (Exception exception)
{
throw;
}
}
/// <summary>
/// Convert input data from json file to metrix of length VxV, where V is number of vertices in graph
/// </summary>
/// <param name="load">load is Data representation from json file</param>
/// <returns></returns>
public static Timetable[,] convert(Data load)
{
Timetable[,] finalData = new Timetable[load.nodeIndices.Length, load.nodeIndices.Length];
foreach (Edge edge in load.edges)
{
if (edge.isTransfer) //is transfer --> within town
{
finalData[edge.from, edge.to] = new Timetable(true, LocalTimePattern.CreateWithInvariantCulture("HH:mm").Parse("00:00").Value);
}
else //is not transfer --> must be edge between 2 towns
//LocalTime duration = LocalTime.Parse(edge.duration);
{
LocalTime duration = LocalTimePattern.CreateWithInvariantCulture("HH:mm").Parse(edge.duration).Value;
int[] lines = new int[edge.timetable.Length];
LocalTime[] times = new LocalTime[edge.timetable.Length];
for (int i = 0; i < edge.timetable.Length; i++)
{
int.TryParse(edge.timetable[i].line, out lines[i]);
times[i] = LocalTimePattern.CreateWithInvariantCulture("HH:mm").Parse(edge.timetable[i].departure).Value;
}
finalData[edge.from, edge.to] = new Timetable(duration, lines, times);
}
}
for (int i = 0; i < load.nodeIndices.Length; i++)
{
for (int j = 0; j < load.nodeIndices.Length; j++)
{
if (i == j) //edge from town into that one town --> edge nullDistance set to true
{
finalData[i, j] = new Timetable(true);
}
else if (finalData[i, j] == null)
{
finalData[i, j] = new Timetable(false);
}
}
}
return(finalData);
}
private static void AssertValidNodaPattern(CultureInfo culture, string pattern)
{
PatternCursor cursor = new PatternCursor(pattern);
while (cursor.MoveNext())
{
if (cursor.Current == '\'')
{
cursor.GetQuotedString('\'');
}
else
{
Assert.IsTrue(ExpectedCharacters.Contains(cursor.Current),
"Pattern '" + pattern + "' contains unquoted, unexpected characters");
}
}
// Check that the pattern parses
LocalTimePattern.Create(pattern, culture);
}
internal void AddEmbeddedTimePattern(
char characterInPattern,
string embeddedPatternText,
Func <TBucket, LocalTimePatternParser.LocalTimeParseBucket> timeBucketExtractor,
Func <TResult, LocalTime> timeExtractor)
{
var templateTime = timeBucketExtractor(CreateSampleBucket()).TemplateValue;
AddField(PatternFields.EmbeddedTime, characterInPattern);
AddEmbeddedPattern(
LocalTimePattern.Create(embeddedPatternText, FormatInfo, templateTime).UnderlyingPattern,
(bucket, value) =>
{
var timeBucket = timeBucketExtractor(bucket);
timeBucket.Hours24 = value.Hour;
timeBucket.Minutes = value.Minute;
timeBucket.Seconds = value.Second;
timeBucket.FractionalSeconds = value.NanosecondOfSecond;
},
timeExtractor);
}
public static JsonSerializerOptions GetSerializerOptions()
{
var options = new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
};
var localTimeConverter = new NodaPatternConverter <LocalTime>(
LocalTimePattern.CreateWithInvariantCulture("HH:mm"));
var localDateConverter = new NodaPatternConverter <LocalDate>(
LocalDatePattern.CreateWithInvariantCulture("yyyy-MM-dd"));
options.Converters.Add(localTimeConverter);
options.Converters.Add(localDateConverter);
options.Converters.Add(new DecimalConverter());
options.Converters.Add(new LongConverter());
options.Converters.Add(new IntConverter());
options.Converters.Add(new DateTimeConverter());
options.Converters.Add(new JsonStringEnumConverter());
return(options);
}
public async Task <IActionResult> OnPost([FromQuery] int year, [FromQuery] int month, [FromQuery] int day)
{
if (!ModelState.IsValid)
{
ErrorMessage = "入力に誤りがあります。";
return(PageResult(year, month, day));
}
if (!SelectedDates.Any())
{
ErrorMessage = "対象の日を1日以上は設定してください。";
return(PageResult(year, month, day));
}
var startTime = LocalTimePattern.Create("HH:mm", CultureInfo.CurrentCulture).Parse(StartTime !);
if (!startTime.Success)
{
ErrorMessage = "入力に誤りがあります。";
return(PageResult(year, month, day));
}
var dates = SelectedDates
.Select(str => LocalDatePattern.CreateWithInvariantCulture("yyyy-MM-dd").Parse(str))
.ToList();
if (dates.Any(r => !r.Success))
{
ErrorMessage = "入力に誤りがあります。";
return(PageResult(year, month, day));
}
var result = await _service.CreateMultipleAppointmentSlotsAsync(dates.Select(d => d.Value).OrderBy(d => d).ToList(), startTime.Value, Period.FromMinutes(DurationMinutesForEachSlot !.Value), CountOfSlotForEachSlot !.Value, CountOfSlotsToCreate !.Value);
if (!result.Succeeded)
{
ErrorMessage = result.ErrorMessage;
return(PageResult(year, month, day));
}
return(RedirectToPage("Index", new { year, month, day }));
}
private static void AssertValidNodaPattern(CultureInfo culture, string pattern)
{
PatternCursor cursor = new PatternCursor(pattern);
while (cursor.MoveNext())
{
if (cursor.Current == '\'')
{
cursor.GetQuotedString('\'');
}
else
{
// We'll never do anything "special" with non-ascii characters anyway,
// so we don't mind if they're not quoted.
if (cursor.Current < '\u0080')
{
Assert.IsTrue(ExpectedCharacters.Contains(cursor.Current),
"Pattern '" + pattern + "' contains unquoted, unexpected characters");
}
}
}
// Check that the pattern parses
LocalTimePattern.Create(pattern, culture);
}
private LocalTime Get(string configText)
{
var parser = LocalTimePattern.CreateWithCurrentCulture("HH:mm").Parse(configText);
return(parser.GetValueOrThrow());
}
public void TemplateValue_DefaultsToMidnight()
{
var pattern = LocalTimePattern.CreateWithInvariantCulture("HH");
Assert.AreEqual(LocalTime.Midnight, pattern.TemplateValue);
}
public void Create_NullFormatInfo()
{
Assert.Throws <ArgumentNullException>(() => LocalTimePattern.Create("HH", null));
}
public void CreateWithInvariantCulture_NullPatternText()
{
Assert.Throws <ArgumentNullException>(() => LocalTimePattern.CreateWithInvariantCulture(null));
}
internal override IPattern <LocalTime> CreatePattern() => LocalTimePattern.CreateWithInvariantCulture(Pattern) .WithTemplateValue(Template) .WithCulture(Culture);
internal LocalTime ReadLocalTime(LocalTimePattern p) => p.Parse(ReadString()).GetValueOrThrow();
/// <summary>
/// Handles date, time and date/time embedded patterns.
/// </summary>
internal void AddEmbeddedLocalPartial(
PatternCursor pattern,
Func <TBucket, LocalDatePatternParser.LocalDateParseBucket> dateBucketExtractor,
Func <TBucket, LocalTimePatternParser.LocalTimeParseBucket> timeBucketExtractor,
Func <TResult, LocalDate> dateExtractor,
Func <TResult, LocalTime> timeExtractor,
// null if date/time embedded patterns are invalid
Func <TResult, LocalDateTime> dateTimeExtractor)
{
// This will be d (date-only), t (time-only), or < (date and time)
// If it's anything else, we'll see the problem when we try to get the pattern.
var patternType = pattern.PeekNext();
if (patternType == 'd' || patternType == 't')
{
pattern.MoveNext();
}
string embeddedPatternText = pattern.GetEmbeddedPattern();
var sampleBucket = CreateSampleBucket();
var templateTime = timeBucketExtractor(sampleBucket).TemplateValue;
var templateDate = dateBucketExtractor(sampleBucket).TemplateValue;
switch (patternType)
{
case '<':
if (dateTimeExtractor == null)
{
throw new InvalidPatternException(Messages.Parse_InvalidEmbeddedPatternType);
}
AddField(PatternFields.EmbeddedDate, 'l');
AddField(PatternFields.EmbeddedTime, 'l');
AddEmbeddedPattern(
LocalDateTimePattern.Create(embeddedPatternText, FormatInfo, templateDate + templateTime).UnderlyingPattern,
(bucket, value) =>
{
var dateBucket = dateBucketExtractor(bucket);
var timeBucket = timeBucketExtractor(bucket);
dateBucket.Calendar = value.Calendar;
dateBucket.Year = value.Year;
dateBucket.MonthOfYearNumeric = value.Month;
dateBucket.DayOfMonth = value.Day;
timeBucket.Hours24 = value.Hour;
timeBucket.Minutes = value.Minute;
timeBucket.Seconds = value.Second;
timeBucket.FractionalSeconds = value.NanosecondOfSecond;
},
dateTimeExtractor);
break;
case 'd':
AddField(PatternFields.EmbeddedDate, 'l');
AddEmbeddedPattern(
LocalDatePattern.Create(embeddedPatternText, FormatInfo, templateDate).UnderlyingPattern,
(bucket, value) =>
{
var dateBucket = dateBucketExtractor(bucket);
dateBucket.Calendar = value.Calendar;
dateBucket.Year = value.Year;
dateBucket.MonthOfYearNumeric = value.Month;
dateBucket.DayOfMonth = value.Day;
},
dateExtractor);
break;
case 't':
AddField(PatternFields.EmbeddedTime, 'l');
AddEmbeddedPattern(
LocalTimePattern.Create(embeddedPatternText, FormatInfo, templateTime).UnderlyingPattern,
(bucket, value) =>
{
var timeBucket = timeBucketExtractor(bucket);
timeBucket.Hours24 = value.Hour;
timeBucket.Minutes = value.Minute;
timeBucket.Seconds = value.Second;
timeBucket.FractionalSeconds = value.NanosecondOfSecond;
},
timeExtractor);
break;
default:
throw new InvalidOperationException("Bug in Noda Time: embedded pattern type wasn't date, time, or date+time");
}
}
/// <summary>
/// Auxiliar method for time parsing
/// </summary>
/// <param name="time"></param>
/// <returns></returns>
public LocalTime parseTime(string time)
{
return(LocalTimePattern.CreateWithInvariantCulture("HH:mm").Parse(time).Value);
}
