private void TryApplyDayLayout(DayOfWeek dayOfWeek, IForecastRegistrationViewModel vm, IEnumerable <ForecastDto> srcForecastDtos)
{
// Get the most frequent layout for the given dayOfWeek.
var dayLayout = _mostFrequentDayLayoutSelector.MostFrequentDayLayout(dayOfWeek, srcForecastDtos);
if (dayLayout == null)
{
return;
}
// Get all days by dayOfWeek
var daysToUpdate = vm.DateColumns.Where(x => x.IsWorkDay && x.Date.DayOfWeek == dayOfWeek);
foreach (var day in daysToUpdate)
{
// Update status type
day.ForecastTypeRegistration.SilentStatusSetById(dayLayout.ForecastType.Id);
// Update dedicated hours for status type
day.ForecastTypeRegistration.DedicatedHours = dayLayout.DedicatedForecastTypeHours;
// Update project hours
foreach (var projHoursSrc in dayLayout.ForecastProjectHoursDtos)
{
var toUpdate = day.ProjectHours.FirstOrDefault(x => x.Parent.ProjectId == projHoursSrc.Project.Id);
if (toUpdate == null)
{
continue;
}
toUpdate.Hours = projHoursSrc.Hours;
}
}
}
public bool CanExecute(IForecastRegistrationViewModel vm)
{
vm.SaveDisabledText = string.Empty;
if (vm.SelectedUserHandler.SelectedUser == null)
{
vm.SaveDisabledText = "Please select a workplan owner";
return(false);
}
if (vm.ForecastMonthIsLocked)
{
vm.SaveDisabledText = "This workplan is locked. Please contact an admin, if you wish to update it";
return(false);
}
if (!vm.IsDirty)
{
return(false);
}
if (!vm.IsValid())
{
vm.SaveDisabledText = "Input is required";
return(false);
}
return(true);
}
public async void Initialize(IForecastRegistrationViewModel forecastRegistrationViewModel)
{
if (_initialized)
{
throw new Exception("ForecastRegistrationSelectedUserHandler may only be initialized once");
}
_forecastRegistrationViewModel = forecastRegistrationViewModel;
// Only load user-selectables if has permission to edit others workplan
if (_userSession.MayEditOthersWorksplan)
{
var searchOptionsResponse = await _forecastService.GetOverivewSearchOptions();
if (searchOptionsResponse == null) // Request failed
{
SetUserFromUserSession();
return;
}
Users = new ObservableCollection <ForecastUserDto>(searchOptionsResponse.Users);
SelectedUser = Users.Single(x => x.UserId == _userSession.CurrentUser.Id); // Set SelectedUser as UserSession
}
else
{
SetUserFromUserSession();
}
_initialized = true;
}
public void Map(ForecastDto src, IForecastRegistrationViewModel vm)
{
// Update corresponding PresenceType
var presenceReg = PresenceRegistrationByDate(src.Date, vm);
presenceReg.SilentStatusSetById(src.ForecastType.Id);
presenceReg.Id = src.Id;
presenceReg.DedicatedHours = src.DedicatedForecastTypeHours;
// Update or create client registrations
if (src.ForecastType.SupportsProjectHours)
{
foreach (var projectHoursDto in src.ForecastProjectHoursDtos)
{
// If client not found create new
var toUpdate = vm.ProjectRegistrations.SingleOrDefault(x => x.ProjectId == projectHoursDto.Project.Id) ??
vm.AddNewProjectRegistration(projectHoursDto.Project.Id, projectHoursDto.Project.Name, projectHoursDto.Project.CompanyDto.Name);
var dateHourReg = toUpdate.Registrations.SingleOrDefault(x => x.DateColumn.Date == src.Date);
if (dateHourReg != null)
{
dateHourReg.Hours = projectHoursDto.Hours;
}
}
}
}
private void ApplyStatusAndProjectHours(IForecastRegistrationViewModel vm, ForecastsByUserAndMonthResponse response)
{
/* We dont want app to crash due to this.
* Just try and dont vomit if an error occurs
* **/
try
{
TryApplyDayLayout(DayOfWeek.Monday, vm, response.ForecastMonth.ForecastDtos);
TryApplyDayLayout(DayOfWeek.Tuesday, vm, response.ForecastMonth.ForecastDtos);
TryApplyDayLayout(DayOfWeek.Wednesday, vm, response.ForecastMonth.ForecastDtos);
TryApplyDayLayout(DayOfWeek.Thursday, vm, response.ForecastMonth.ForecastDtos);
TryApplyDayLayout(DayOfWeek.Friday, vm, response.ForecastMonth.ForecastDtos);
}
catch (Exception exp)
{
var msg = new StringBuilder()
.AppendLine("I had problems trying to copy hours.")
.AppendLine("Hours will not be copied.")
.AppendLine("Please contact someone.")
.AppendLine("Sry...")
.AppendLine()
.AppendLine(exp.ToString());
_commonDialogs.Error(msg.ToString());
}
}
private static void ApplyProjects(IForecastRegistrationViewModel vm, IEnumerable <ProjectDto> projectDtos)
{
foreach (var project in projectDtos)
{
vm.AddNewProjectRegistration(project.Id, project.Name, project.CompanyDto.Name);
}
}
public async void Execute(IForecastRegistrationViewModel vm)
{
// Initialize datecolumns
var selectedDate = vm.SelectedDate;
var prevMonth = selectedDate.FirstDayOfPreviousMonth();
_forecastRegistrationDataGenerator.GenerateBaseDataByDate(vm.SelectedDate, vm); // Initializes a "clean" month
// Get data from last month
var response = await _forecastService.GetByUserIdAndMonth(_selectedUserHandler.UserId, prevMonth.Month, prevMonth.Year, selectedDate.Month, selectedDate.Year);
// Merge fetched holidays
_forecastRegistrationDataGenerator.MergeHolidays(vm, response.Holidays);
var projectDtos = response
.ForecastMonth
.ForecastDtos
.Where(forecast => forecast.ForecastType.SupportsProjectHours)
.SelectMany(forecast => forecast.ForecastProjectHoursDtos)
.Select(forecastHoursDto => forecastHoursDto.Project)
.Distinct();
ApplyProjects(vm, projectDtos);
ApplyStatusAndProjectHours(vm, response);
vm.RaisePresenceRegistrationsOnPropertyChanged();
vm.CalculateTotals();
vm.DateColumns.EnableClientHours();
}
public ForecastRegistrationRootViewModel(IAppSettings appSettings
, IForecastRegistrationViewModel forecastRegistrationVm
, IForecastStatisticsTabViewModel forecastStatisticsTabVm)
{
_appSettings = appSettings;
ForecastRegistrationVm = forecastRegistrationVm;
ForecastStatisticsTabVm = forecastStatisticsTabVm;
}
public bool CanExecute(IForecastRegistrationViewModel vm)
{
if (vm.ForecastMonthIsLocked)
{
return(false);
}
return(vm.IsDirty);
}
/// <summary>
/// Sets date-relating DateColumns to Holiday
/// </summary>
/// <param name="vm"></param>
/// <param name="holidays"></param>
public virtual void MergeHolidays(IForecastRegistrationViewModel vm, List <HolidayDto> holidays)
{
foreach (var holiday in holidays)
{
// Must exist. If not there is something wrong with date-generation
var toUpdate = vm.DateColumns.Single(x => x.Date == holiday.Date);
toUpdate.SetToHoliday(holiday);
}
}
private static void InitializeIsEditEnabled(IForecastRegistrationViewModel viewModel, HourRegistration hourReg)
{
// Get the presenceregistration on the same date, and set IsEditEnabled
var dateItemSibling = viewModel
.PresenceRegistrations
.Single(x => x.DateColumn.Equals(hourReg.DateColumn));
hourReg.InitializeIsEditEnabled(dateItemSibling.SelectedForecastType);
}
/// <summary>
/// If data exists ask user to continue
/// </summary>
/// <param name="vm"></param>
/// <returns></returns>
public bool ShouldContinue(IForecastRegistrationViewModel vm)
{
if (vm.ProjectRegistrations.Count == 0 && vm.PresenceRegistrations.All(x => (x.SelectedForecastType.Equals(_forecastTypeProvider.Default))))
{
return(true);
}
return(_commonDialogs.ContinueWarning("Data already exists for this month!\n\nContinue with overwrite?", "Overwrite"));
}
public void MergeForecastMonth(IForecastRegistrationViewModel vm, ForecastMonthDto forecastMonth)
{
vm.ForecastMonthId = forecastMonth.Id;
vm.ForecastMonthIsLocked = forecastMonth.IsLocked;
vm.Initializing = true;
foreach (var forecast in forecastMonth.ForecastDtos)
{
_guiMapper.Map(forecast, vm);
}
vm.ProjectRegistrations.InitializeDirtyCheck();
vm.Initializing = false;
vm.CalculateTotals();
}
public void Execute(IForecastRegistrationViewModel vm)
{
var msg = new StringBuilder()
.AppendLine("All unsaved changes will be lost!")
.AppendLine()
.AppendLine("Continue with reset?");
if (!_commonDialogs.ContinueWarning(msg.ToString(), "Reset"))
{
return;
}
vm.RefreshViewData();
}
/// <summary>
/// Generates date columns for view
/// </summary>
/// <param name="date"></param>
/// <param name="viewModel"></param>
public virtual void GenerateBaseDataByDate(DateTime date, IForecastRegistrationViewModel viewModel)
{
viewModel.Initializing = true;
CleanUp(viewModel);
// 1. Generate dates for month
var dateHeaders = CreateDateColumns(date);
// 2. Initialize Headers
viewModel.DateColumns = dateHeaders;
// 3. Initialize Presence registrations
InitializeForecastTypeRegistrations(viewModel);
viewModel.RaisePresenceRegistrationsOnPropertyChanged();
viewModel.Initializing = false;
}
public virtual void InitializeForecastTypeRegistrations(IForecastRegistrationViewModel vm)
{
foreach (var dateColumn in vm.DateColumns)
{
var forecastTypeReg = new ForecastTypeRegistration(_forecastTypeProvider.Default, _forecastTypeProvider.ForecastTypes);
dateColumn.ForecastTypeRegistration = forecastTypeReg;
// Initialize commands here, since contextmenu is not part of visual-tree (cant use FindAncestor on binding)
_copyStatusCommandHandler.InitializePresenceCopyCommands(forecastTypeReg, vm.PresenceRegistrations);
// Selected PresenceType affects validation and commands.
forecastTypeReg.ForecastTypeRegistrationChanged.Subscribe(_ =>
{
vm.CalculateTotals();
vm.RaiseCanExecuteActions();
});
}
}
/// <summary>
/// Manually dispose items making sure that subscriptions
/// are closed
/// </summary>
/// <param name="vm"></param>
private void CleanUp(IForecastRegistrationViewModel vm)
{
vm.DateColumns = null;
if (vm.PresenceRegistrations != null)
{
foreach (var presenceRegistration in vm.PresenceRegistrations)
{
presenceRegistration.Dispose();
}
}
foreach (var project in vm.ProjectRegistrations)
{
project.Dispose();
}
vm.ProjectRegistrations.Clear();
vm.DateRealizedTotals = null;
}
public async void Execute(IForecastRegistrationViewModel vm)
{
if (!vm.IsValid())
{
return;
}
vm.IsBusy = true;
var forecastMonthDto = new ForecastMonthDto
{
Id = vm.ForecastMonthId,
Month = vm.SelectedDate.Month,
Year = vm.SelectedDate.Year,
UserId = _selectedUserHandler.UserId,
CreatedById = _userSession.CurrentUser.Id,
ForecastDtos = vm.DateColumns
.GetItemsToSave(vm.ProjectForecastTypeId)
.Select(col => new ForecastDto
{
Date = col.Date,
DedicatedForecastTypeHours = col.SelectedForecastTypeDedicatedHours,
ForecastType = col.ForecastType.ToServerDto(),
ForecastProjectHoursDtos = col.ProjectHoursWithValue.Select(BuildForecastProjectHoursDto).ToList()
}).ToList()
};
var saveResponse = await _forecastService.SaveForecasts(forecastMonthDto);
// Null if an error occured
if (saveResponse != null)
{
vm.ForecastMonthId = saveResponse.ForecastMonthId;
}
vm.IsBusy = false;
vm.InitializeDirtyCheck();
vm.RaiseCanExecuteActions();
ApplicationCommands.GetForecastStatistics.Execute(vm.SelectedDate);
}
public bool CanExecute(IForecastRegistrationViewModel vm)
{
return(!vm.ForecastMonthIsLocked && !vm.IsBusy);
}
public virtual ObservableCollection <ProjectHourRegistration> CreateProjectHoursFromHeaders(IEnumerable <ForecastRegistrationDateColumn> dateHeaders
, IForecastRegistrationViewModel viewModel
, ProjectRegistration parent)
{
var result = new ObservableCollection <ProjectHourRegistration>();
foreach (var dateHeader in dateHeaders)
{
var projectHours = new ProjectHourRegistration(parent);
dateHeader.AddProjectHours(projectHours);
// Hookup for updating totals
var dateItem = projectHours.DateColumn;
projectHours
.HoursUpdated
.Subscribe(x =>
{
viewModel.CalculateTotals(dateItem);
viewModel.RaiseCanExecuteActions();
});
InitializeIsEditEnabled(viewModel, projectHours);
result.Add(projectHours);
}
return(result);
}
public ForecastTypeRegistration PresenceRegistrationByDate(DateTime date, IForecastRegistrationViewModel vm)
{
return(vm.PresenceRegistrations.Single(x => x.DateColumn.Date.Date == date.Date));
}
