public async Task ReturnsTheRowCountOfCurrentlyShownMonth(
int currentYear,
int currentMonth,
int currentPage,
BeginningOfWeek beginningOfWeek,
int expectedRowCount)
{
var observer = TestScheduler.CreateObserver <int>();
var now = new DateTimeOffset(currentYear, currentMonth, 1, 0, 0, 0, TimeSpan.Zero);
TimeService.MidnightObservable.Returns(Observable.Never <DateTimeOffset>());
TimeService.CurrentDateTime.Returns(now);
var user = Substitute.For <IThreadSafeUser>();
user.BeginningOfWeek.Returns(beginningOfWeek);
DataSource.User.Current.Returns(Observable.Return(user));
ViewModel.Prepare();
await ViewModel.Initialize();
ViewModel.RowsInCurrentMonthObservable
.Subscribe(observer);
ViewModel.SetCurrentPage(currentPage);
TestScheduler.Start();
var rowsInCurrentMonth = observer.Values().Last();
rowsInCurrentMonth.Should().Be(expectedRowCount);
}
public void AlwaysIsAMultipleOf7(
NonNegativeInt year,
NonNegativeInt month,
BeginningOfWeek beginingOfWeek)
{
prepare(year.Get % 9999 + 2, month.Get % 12 + 1, beginingOfWeek);
(viewModel.Days.Count % 7).Should().Be(0);
}
private IReadOnlyList <string> mapDayHeaders(BeginningOfWeek newBeginningOfWeek)
{
var updatedDayHeaders = new List <string>();
for (var i = 0; i < dayHeaders.Length; i++)
{
updatedDayHeaders.Add(dayHeaderFor(i, newBeginningOfWeek));
}
return(updatedDayHeaders.AsReadOnly());
}
public void InitializesTheBeginningOfWeekProperty(BeginningOfWeek beginningOfWeek)
{
var user = Substitute.For <IThreadSafeUser>();
user.BeginningOfWeek.Returns(beginningOfWeek);
DataSource.User.Current.Returns(Observable.Return(user));
TimeService.CurrentDateTime.Returns(new DateTimeOffset(2018, 4, 20, 16, 20, 0, TimeSpan.Zero));
ViewModel.Prepare();
ViewModel.Initialize().Wait();
ViewModel.BeginningOfWeek.Should().Be(beginningOfWeek);
}
public override async Task Initialize()
{
await base.Initialize();
var now = timeService.CurrentDateTime;
initialMonth = new CalendarMonth(now.Year, now.Month).AddMonths(-(MonthsToShow - 1));
beginningOfWeekObservable = dataSource.User.Current
.Select(user => user.BeginningOfWeek)
.DistinctUntilChanged();
DayHeadersObservable = beginningOfWeekObservable.Select(mapDayHeaders);
ReloadObservable = reloadSubject.AsObservable();
MonthsObservable = beginningOfWeekObservable.CombineLatest(
timeService.MidnightObservable.StartWith(timeService.CurrentDateTime),
(beginningOfWeek, today) =>
{
var monthIterator = new CalendarMonth(today.Year, today.Month).AddMonths(-(MonthsToShow - 1));
var months = new List <ReportsCalendarPageViewModel>();
for (int i = 0; i < MonthsToShow; i++, monthIterator = monthIterator.Next())
{
months.Add(new ReportsCalendarPageViewModel(monthIterator, beginningOfWeek, today));
}
return(months);
});
RowsInCurrentMonthObservable = MonthsObservable.CombineLatest(
CurrentPageObservable.DistinctUntilChanged(),
(months, page) => months[page].RowCount)
.Select(CommonFunctions.Identity);
CurrentMonthObservable = monthSubject
.AsObservable()
.StartWith(MonthsToShow - 1)
.Select(convertPageIndexToCalendarMonth)
.Share();
QuickSelectShortcutsObservable = beginningOfWeekObservable.Select(createQuickSelectShortcuts);
beginningOfWeek = (await dataSource.User.Current.FirstAsync()).BeginningOfWeek;
QuickSelectShortcuts = createQuickSelectShortcuts(beginningOfWeek);
SelectPeriod(reportPeriod);
isInitialized = true;
viewAppearedOnce = false;
}
public ReportsCalendarPageViewModel(
CalendarMonth calendarMonth, BeginningOfWeek beginningOfWeek, DateTimeOffset today)
{
this.beginningOfWeek = beginningOfWeek;
this.today = today.RoundDownToLocalDate();
CalendarMonth = calendarMonth;
addDaysFromPreviousMonth();
addDaysFromCurrentMonth();
addDaysFromNextMonth();
RowCount = Days.Count / 7;
}
public void MarksTheCurrentDayAndNoOtherDayAsToday(
int year,
int month,
int today,
BeginningOfWeek beginningOfWeek)
{
year = Math.Abs(year % 25) + 2000;
month = Math.Abs(month % 12) + 1;
today = Math.Abs(today % DateTime.DaysInMonth(year, month)) + 1;
prepare(year, month, beginningOfWeek, new DateTimeOffset(year, month, today, 11, 22, 33, TimeSpan.Zero));
viewModel.Days.Should().OnlyContain(day =>
((day.CalendarMonth.Month != month || day.Day != today) && day.IsToday == false) ||
(day.CalendarMonth.Month == month && day.Day == today && day.IsToday));
}
public void ConainsAllDaysFromCurrentMonthInTheMiddle(
int year,
int month,
BeginningOfWeek beginningOfWeek,
int daysFromLastMonth)
{
prepare(year, month, beginningOfWeek);
viewModel
.Days
.Skip(daysFromLastMonth)
.Take(calendarMonth.DaysInMonth)
.Should()
.OnlyContain(day => day.IsInCurrentMonth);
}
public async Task EmitsCorrectStringWhenDateRangeIsSelected(BeginningOfWeek beginningOfWeek, DateTimeOffset startDate, DateTimeOffset endDate, string result)
{
var user = new MockUser {
BeginningOfWeek = beginningOfWeek
};
DataSource.User.Current.Returns(Observable.Return(user));
var observer = TestScheduler.CreateObserver <string>();
var now = DateTimeOffset.Now;
TimeService.CurrentDateTime.Returns(now);
ViewModel.CurrentDateRange.Subscribe(observer);
await ViewModel.Initialize();
await ViewModel.LoadReport(0, startDate, endDate, ReportsSource.Calendar);
TestScheduler.Start();
observer.LastEmittedValue().Should().Be($"{result} ▾");
}
public async Task EmitsThisWeekWhenCurrentWeekIsSelected(BeginningOfWeek beginningOfWeek)
{
var user = new MockUser {
BeginningOfWeek = beginningOfWeek
};
DataSource.User.Current.Returns(Observable.Return(user));
var observer = TestScheduler.CreateObserver <string>();
var now = DateTimeOffset.Now;
TimeService.CurrentDateTime.Returns(now);
ViewModel.CurrentDateRangeStringObservable.Subscribe(observer);
await ViewModel.Initialize();
ViewModel.CalendarViewModel.SelectPeriod(Core.Services.ReportPeriod.ThisWeek);
TestScheduler.Start();
observer.LastEmittedValue().Should().Be($"{Resources.ThisWeek} ▾");
}
public async Task CorrespondsToSettings(BeginningOfWeek beginningOfWeek)
{
System.Diagnostics.Debug.WriteLine(beginningOfWeek);
var now = new DateTimeOffset(2019, 1, 1, 10, 12, 14, TimeSpan.Zero);
var start = now.AddHours(-2);
var parameter = DurationParameter.WithStartAndDuration(start, null);
TimeService.CurrentDateTime.Returns(now);
var user = Substitute.For <IThreadSafeUser>();
user.BeginningOfWeek.Returns(beginningOfWeek);
user.Id.Returns(123456);
DataSource.User.Current.Returns(Observable.Return(user));
var viewModel = CreateViewModel();
await viewModel.Initialize(new EditDurationParameters(parameter));
TestScheduler.Start();
viewModel.BeginningOfWeek.Should().Be(beginningOfWeek);
}
public void ContainsFewDaysFromPreviousMonthAtTheBeginning(
int year,
int month,
BeginningOfWeek beginningOfWeek,
int expectedDayCount)
{
prepare(year, month, beginningOfWeek);
if (expectedDayCount == 0)
{
viewModel.Days.First().IsInCurrentMonth.Should().BeTrue();
}
else
{
viewModel
.Days
.Take(expectedDayCount)
.Should()
.OnlyContain(day => !day.IsInCurrentMonth);
}
}
public async Task ReturnsTheRowCountOfCurrentlyShownMonth(
int currentYear,
int currentMonth,
int currentPage,
BeginningOfWeek beginningOfWeek,
int expectedRowCount)
{
var now = new DateTimeOffset(currentYear, currentMonth, 1, 0, 0, 0, TimeSpan.Zero);
TimeService.CurrentDateTime.Returns(now);
var user = Substitute.For <IThreadSafeUser>();
user.BeginningOfWeek.Returns(beginningOfWeek);
DataSource.User.Current.Returns(Observable.Return(user));
ViewModel.Prepare();
await ViewModel.Initialize();
ViewModel.CurrentPage = currentPage;
ViewModel.RowsInCurrentMonth.Should().Be(expectedRowCount);
}
public void ContainsFewDaysFromNextMonthAtTheEnd(
int year,
int month,
BeginningOfWeek beginningOfWeek,
int daysFromLastMonth,
int expectedDayCount)
{
prepare(year, month, beginningOfWeek);
var daysFromNextMonth = viewModel
.Days
.Skip(daysFromLastMonth)
.Skip(calendarMonth.DaysInMonth);
if (expectedDayCount == 0)
{
daysFromNextMonth.Should().BeEmpty();
}
else
{
daysFromNextMonth.Should().OnlyContain(day => !day.IsInCurrentMonth);
}
}
public static SelectTimeParameters CreateFromOrigin(Origin origin, BeginningOfWeek beginningOfWeek, DateTimeOffset start, DateTimeOffset?stop = null)
{
var allowedParameters = new Dictionary <Origin, (int, bool)>
{
protected SelectTimeParameters CreateParameter(DateTimeOffset start, DateTimeOffset?stop, BeginningOfWeek beginningOfWeek = BeginningOfWeek.Sunday)
{
var dateFormat = DateFormat.FromLocalizedDateFormat("MM.DD.YYYY");
var timeFormat = TimeFormat.FromLocalizedTimeFormat("H:mm");
return(SelectTimeParameters
.CreateFromOrigin(StartTime, beginningOfWeek, start, stop)
.WithFormats(dateFormat, timeFormat));
}
public void LocalizesToEnglishProperly(BeginningOfWeek beginningOfWeek, string translation)
{
CultureInfo.CurrentCulture = new CultureInfo("en");
beginningOfWeek.ToLocalizedString().Should().Be(translation);
}
public static DateTimeOffset BeginningOfWeek(this DateTimeOffset time, BeginningOfWeek beginningOfWeek)
{
int diff = (7 + ((BeginningOfWeek)time.DayOfWeek - beginningOfWeek)) % 7;
return(time.AddDays(-1 * diff).Date);
}
public void ReturnsTheCorrectDate(
DateTimeOffset now, BeginningOfWeek beginningOfWeek, DateTimeOffset expectedResult)
{
now.BeginningOfWeek(beginningOfWeek).Should().Be(expectedResult);
}
private void prepare(
int year, int month, BeginningOfWeek beginningOfWeek, DateTimeOffset?today = null)
{
calendarMonth = new CalendarMonth(year, month);
viewModel = new CalendarPageViewModel(calendarMonth, beginningOfWeek, today ?? DateTimeOffset.Now);
}
public ReportsCalendarLastWeekQuickSelectShortcut(
ITimeService timeService, BeginningOfWeek beginningOfWeek)
: base(timeService, Resources.LastWeek, ReportPeriod.LastWeek)
{
this.beginningOfWeek = beginningOfWeek;
}
public void CreateTodayString()
{
DateTime BeginningOfWeek;
// Save the EST Time.
if (DateTime.Now.IsDaylightSavingTime())
{
todayEST = todayUTC.Subtract(TimeSpan.FromHours(4));
}
else
{
todayEST = todayUTC.Subtract(TimeSpan.FromHours(5));
}
// Get the index of the current Weekday
string weekday = todayEST.DayOfWeek.ToString();
int DaysSinceMonday = -1;
for (int i = 0; i < Enum.GetNames(typeof(Days)).Length; i++)
{
if (Enum.GetNames(typeof(Days))[i].Contains(weekday))
{
DaysSinceMonday = i;
}
}
BeginningOfWeek = todayEST.Subtract(TimeSpan.FromDays(DaysSinceMonday));
WeekOfString = "Week of " + BeginningOfWeek.DayOfWeek.ToString() + ", " + BeginningOfWeek.ToString(@"MM\/dd\/yyyy") + " (EST)";
}
public static string ToLocalizedString(this BeginningOfWeek beginningOfWeek) => CultureInfo.CurrentCulture.DateTimeFormat.DayNames[(int)beginningOfWeek];
private void onBeginningOfWeekChanged(BeginningOfWeek beginningOfWeek)
{
this.beginningOfWeek = beginningOfWeek;
updateCurrentDateRangeString();
}
public CalendarThisWeekQuickSelectShortcut
(ITimeService timeService, BeginningOfWeek beginningOfWeek)
: base(timeService, Resources.ThisWeek)
{
this.beginningOfWeek = beginningOfWeek;
}
public SelectableBeginningOfWeekViewModel(BeginningOfWeek beginningOfWeek, bool selected)
{
BeginningOfWeek = beginningOfWeek;
Selected = selected;
}
private List <ReportsCalendarBaseQuickSelectShortcut> createQuickSelectShortcuts(BeginningOfWeek beginningOfWeek)
=> new List <ReportsCalendarBaseQuickSelectShortcut>
{
new ReportsCalendarTodayQuickSelectShortcut(timeService),
new ReportsCalendarYesterdayQuickSelectShortcut(timeService),
new ReportsCalendarThisWeekQuickSelectShortcut(timeService, beginningOfWeek),
new ReportsCalendarLastWeekQuickSelectShortcut(timeService, beginningOfWeek),
new ReportsCalendarThisMonthQuickSelectShortcut(timeService),
new ReportsCalendarLastMonthQuickSelectShortcut(timeService),
new ReportsCalendarThisYearQuickSelectShortcut(timeService),
new ReportsCalendarLastYearQuickSelectShortcut(timeService)
};
private string dayHeaderFor(int index, BeginningOfWeek newBeginningOfWeek) => dayHeaders[(index + (int)newBeginningOfWeek + 7) % 7];
public Builder SetBeginningOfWeek(BeginningOfWeek beginningOfWeek)
{
BeginningOfWeek = beginningOfWeek;
return(this);
}
public static DayOfWeek ToDayOfWeekEnum(this BeginningOfWeek self) => (DayOfWeek)self;
