public BurndownViewModel(
[Import] IBacklogService backlogService,
[Import] IProjectsService projectsService,
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator,
[Import] IAuthorizationService authorizator)
{
this.backlogService = backlogService;
this.projectsService = projectsService;
this.executor = backgroundExecutor;
this.aggregator = eventAggregator;
this.authorizator = authorizator;
NeedRefresh = false;
OnLoadCommand = new DelegateCommand(() => {if (NeedRefresh) LoadData();});
SetBaselineCommand = new DelegateCommand(_CanChangeBaseline, SetBaseline);
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, p=> {
Project = p;
SetPlannings();
AskForRefresh();
});
aggregator.Subscribe<Project>(ScrumFactoryEvent.BurndownShouldRefresh, AskForRefresh);
aggregator.Subscribe<ICollection<Sprint>>(ScrumFactoryEvent.SprintsDateChanged, o => { AskForRefresh(); });
aggregator.Subscribe<BacklogItem[]>(ScrumFactoryEvent.BacklogItemsChanged, b => { AskForRefresh(); });
}
public MemberViewModel(
[Import(typeof(IAuthorizationService))] IAuthorizationService authorizator,
[Import(typeof(IBackgroundExecutor))] IBackgroundExecutor executor,
[Import(typeof(IEventAggregator))] IEventAggregator aggregator,
[Import] IDialogService dialogs,
[Import(typeof(ITasksService))] ITasksService taskService,
[Import(typeof(ITeamService))] ITeamService teamService)
{
this.taskService = taskService;
this.authorizator = authorizator;
this.executor = executor;
this.aggregator = aggregator;
this.teamService = teamService;
this.dialogs = dialogs;
aggregator.Subscribe(ScrumFactoryEvent.ShowProfile, Show);
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);
ChangeAvatarCommand = new DelegateCommand(ChangeMemberImage);
RemoveAvatarCommand = new DelegateCommand(RemoveMemberImage);
CloseWindowCommand = new DelegateCommand(Close);
CreateAvatarCommand = new DelegateCommand(CreateAvatar);
UpdateAvatarCommand = new DelegateCommand(() => {
executor.StartBackgroundTask(
() => {
teamService.UpdateMember(authorizator.SignedMemberProfile.MemberUId, MemberProfile);
}, () => {
myProfileNocache = new Random().Next().ToString();
DefineMemberAvatarUrl();
});
});
}
public ProposalsListViewModel(
[Import]IBackgroundExecutor executor,
[Import]IEventAggregator eventAggregator,
[Import]IDialogService dialogs,
[Import]IAuthorizationService authorizator,
[Import]IBacklogService backlogService,
[Import]IProposalsService proposalsService)
{
this.executor = executor;
this.dialogs = dialogs;
this.aggregator = eventAggregator;
this.authorizator = authorizator;
this.proposalsService = proposalsService;
this.backlogService = backlogService;
this.aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);
this.aggregator.Subscribe(ScrumFactoryEvent.RoleHourCostsChanged, LoadProposals);
this.aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);
this.aggregator.Subscribe(ScrumFactoryEvent.ApplicationWhentBackground, () => { ShowValues = false; });
OnLoadCommand = new DelegateCommand(CanSeeProposals, () => {
ShowValues = false;
if (NeedRefresh) LoadProposals();
});
AddProposalCommand = new DelegateCommand(CanSeeProposals, AddProposal);
ShowDetailCommand = new DelegateCommand<Proposal>(CanSeeProposals, ShowDetail);
ShowHourCostsCommand = new DelegateCommand(CanSeeProposals, ShowHourCosts);
}
public OwnersListViewModel(
[Import]IEventAggregator eventAggregator,
[Import]ITeamService teamServices,
[Import]IBackgroundExecutor backgroundExecutor,
[Import] IDialogService dialogs,
[Import]IAuthorizationService authorizationService)
{
this.aggregator = eventAggregator;
this.teamServices = teamServices;
this.executor = backgroundExecutor;
this.authorizator = authorizationService;
this.dialogs = dialogs;
aggregator.Subscribe(ScrumFactoryEvent.ShowOwnersList, Show);
CloseWindowCommand = new DelegateCommand(CloseWindow);
OnLoadCommand = new DelegateCommand(LoadOwners);
ChangeFactoryOwnerCommand = new DelegateCommand<string>(ChangeFactoryOwner);
ChangeCanSeeProposalsCommand = new DelegateCommand<string>(ChangeCanSeeProposals);
AddNewMemberCommand = new DelegateCommand(AddNewMember);
RefreshMemberFilter = LoadMembers;
}
public UserTasksSelectorViewModel(
[Import]IBackgroundExecutor executor,
[Import]IEventAggregator aggregator,
[Import]ITasksService tasksService,
[Import] IDialogService dialogs,
[Import]IAuthorizationService authorizator)
{
this.executor = executor;
this.aggregator = aggregator;
this.tasksService = tasksService;
this.dialogs = dialogs;
this.authorizator = authorizator;
tasksViewSource = new System.Windows.Data.CollectionViewSource();
notMineTasksViewSource = new System.Windows.Data.CollectionViewSource();
TrackingTaskInfo = null;
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, m => { OnPropertyChanged("SignedMemberUId"); });
aggregator.Subscribe(ScrumFactoryEvent.ApplicationWhentForeground, () => { LoadTasks(true); });
aggregator.Subscribe(ScrumFactoryEvent.ShowUserTasksSelector, Show);
aggregator.Subscribe<Task>(ScrumFactoryEvent.TaskAssigneeChanged, OnTaskChanged);
aggregator.Subscribe<Task>(ScrumFactoryEvent.TaskChanged, OnTaskChanged);
ShowTaskDetailCommand = new DelegateCommand<TaskViewModel>(ShowTaskDetail);
TrackTaskCommand = new DelegateCommand<TaskViewModel>(TrackTask);
timeKeeper.Tick += new EventHandler(timeKeeper_Tick);
}
public SizeListViewModel(
[Import] IBacklogService backlogService,
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator,
[Import] IDialogService dialogs,
[Import] IAuthorizationService authorizator)
{
this.backlogService = backlogService;
this.executor = backgroundExecutor;
this.aggregator = eventAggregator;
this.authorizator = authorizator;
this.dialogs = dialogs;
AddNewSizeCommand = new DelegateCommand(CanEditItemSizes, AddNewSize);
CloseWindowCommand = new DelegateCommand(CloseWindow);
DeleteSizeCommand = new DelegateCommand<SizeViewModel>(CanEditItemSizes, DeleteSize);
SetAsPlanningItemCommand = new DelegateCommand<SizeViewModel>(CanEditItemSizes, size => SetItemOccurrenceContraint(size, ItemOccurrenceContraints.PLANNING_OCC));
SetAsDeliveryItemCommand = new DelegateCommand<SizeViewModel>(CanEditItemSizes, size => SetItemOccurrenceContraint(size, ItemOccurrenceContraints.DELIVERY_OCC));
sizesViewSource = new System.Windows.Data.CollectionViewSource();
sizesViewSource.Filter += new System.Windows.Data.FilterEventHandler(sizesViewSource_Filter);
delayFilter = new DelayAction(1200, new DelayAction.ActionDelegate(() => { FilteredSizes.Refresh(); }));
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged,
m => {
RefreshCommands();
if (m == null) return;
if (Sizes!=null) return;
LoadItemSizes();
});
}
public BacklogViewModel(
[Import] IBacklogService backlogService,
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator)
{
this.backlogService = backlogService;
this.backgroundExecutor = backgroundExecutor;
this.eventAggregator = eventAggregator;
this.Items = new ObservableCollection<BacklogItem>();
this.eventAggregator.Subscribe<Project>(
"ViewProjectDetails",
p =>
{
this.projectId = p.Id;
this.backgroundExecutor.StartBackgroundTask<ICollection<BacklogItem>>(
() =>
{
return this.backlogService.GetBacklog(p.Id);
},
i =>
{
this.Items.Clear();
foreach (var item in i)
{
this.Items.Add(item);
}
});
});
this.SaveBacklogCommand = new DelegateCommand(() =>
{
this.backgroundExecutor.StartBackgroundTask(
() =>
{
this.backlogService.SaveBacklog(this.projectId, this.Items);
},
() => { });
});
this.DeleteBacklogItemCommand = new DelegateCommand<BacklogItem>(item =>
{
this.Items.Remove(item);
});
this.AddBacklogItemCommand = new DelegateCommand(() =>
{
this.Items.Add(
new BacklogItem
{
Description = this.NewItemDescription,
ProjectId = this.projectId
});
});
}
public ProjectMembershipViewModel(
IBackgroundExecutor executor,
IProjectsService projectsService,
IAuthorizationService authorizatorService,
ProjectMembership membership,
MemberProfile member)
{
Init(executor, projectsService, authorizatorService, membership, member);
}
/// <summary>
/// Constructor for lifeless viewmodels.
/// </summary>
/// <param name="executor"></param>
/// <param name="tasksService"></param>
/// <param name="aggregator"></param>
/// <param name="authorizationService"></param>
/// <param name="task"></param>
public TaskViewModel(
IBackgroundExecutor executor,
ITasksService tasksService,
IEventAggregator aggregator,
IDialogService dialogs,
IAuthorizationService authorizationService,
Task task,
UserTasksSelectorViewModel selector)
{
if(task!=null)
Task = task;
this.executor = executor;
this.tasksService = tasksService;
this.aggregator = aggregator;
this.authorizator = authorizationService;
this.selectorViewModel = selector;
this.dialogs = dialogs;
aggregator.Subscribe<ICollection<MemberProfile>>(ScrumFactoryEvent.ProjectMembersChanged, OnMembersChanged);
aggregator.Subscribe<string>(ScrumFactoryEvent.TaskTrackChanged, OnTaskTrackChanged);
aggregator.Subscribe(ScrumFactoryEvent.ApplicationWhentBackground, OnApplicationWhentBackground);
aggregator.Subscribe<bool>(ScrumFactoryEvent.TaskReplanItemChanged, r => { ReplanItemWhenChanged = r; });
MoveTaskToCommand = new DelegateCommand<short>(MoveTaskTo);
MoveTaskLeftCommand = new DelegateCommand(CanMoveTaskLeft, MoveTaskLeft);
MoveTaskRightCommand = new DelegateCommand(CanMoveTaskRight, MoveTaskRight);
CancelTaskCommand = new DelegateCommand(CanCancelTask, CancelTask);
FinishTaskCommand = new DelegateCommand(CanFinishTask, FinishTask);
AssignTaskToMeCommand = new DelegateCommand(AssignTaskToMe);
CopyTaskTrackIdCommand = new DelegateCommand(CopyTaskTrackId);
ShowDetailCommand = new DelegateCommand(Show);
ShowFinishDialogCommand = new DelegateCommand(ShowFinishDialog);
ChangeTaskNameCommand = new DelegateCommand(ChangeTaskName);
ChangePlannedHoursCommand = new DelegateCommand(ChangePlannedHours);
ChangeEffectiveHoursCommand = new DelegateCommand(ChangeEffectiveHours);
ChangeTaskAssigneeCommand = new DelegateCommand(ChangeTaskAssigneeUId);
ChangeTaskItemCommand = new DelegateCommand<string>(ChangeTaskItem);
ShowRepositoryLogCommand = new DelegateCommand(ShowRepositoryLog);
TrackTaskCommand = new DelegateCommand(TrackTask);
ResetTaskAssigneeCommand = new DelegateCommand(ResetTaskAssignee);
}
public ProjectViewModel(
[Import] IProjectsService projectsService,
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator)
{
this.projectsService = projectsService;
this.executor = backgroundExecutor;
this.aggregator = eventAggregator;
CloseWindowCommand = new DelegateCommand(CloseWindow);
}
public ServerConfigurationViewModel(
[Import] IEventAggregator aggregator,
[Import] IBackgroundExecutor executor)
{
this.aggregator = aggregator;
this.executor = executor;
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, m => { NeedRefresh = true; });
UploadLogoCommand = new DelegateCommand(UploadLogo);
ApplyCommand = new DelegateCommand(Apply);
}
public RiskViewModel(
IBackgroundExecutor executor,
IProjectsService projectsService,
Risk risk)
{
this.executor = executor;
this.projectsService = projectsService;
Risk = risk;
ChangeRiskImpactCommand = new DelegateCommand(ChangeRiskImpact);
ChangeRiskProbabilityCommand = new DelegateCommand(ChangeRiskProbability);
}
public RiskViewModel(
[Import] IBackgroundExecutor executor,
[Import] IEventAggregator aggregator,
[Import] IDialogService dialogs,
[Import] IProjectsService projectsService)
{
this.executor = executor;
this.aggregator = aggregator;
this.projectsService = projectsService;
this.dialogs = dialogs;
CloseWindowCommand = new DelegateCommand(CloseWindow);
}
public ProjectTeamViewModel(
[Import]IEventAggregator eventAggregator,
[Import]IProjectsService projectsServices,
[Import]ITeamService teamServices,
[Import]ITasksService taskServices,
[Import]IBackgroundExecutor backgroundExecutor,
[Import] IDialogService dialogs,
[Import]IAuthorizationService authorizationService)
{
this.taskServices = taskServices;
this.aggregator = eventAggregator;
this.projectsServices = projectsServices;
this.teamServices = teamServices;
this.executor = backgroundExecutor;
this.authorizator = authorizationService;
this.dialogs = dialogs;
ShowRolesListCommand = new DelegateCommand(CanShowRoleList, ShowRolesList);
AddNewMemberCommand = new DelegateCommand(CanAddNewMember, AddNewMember);
RemoveMemberCommand = new DelegateCommand<ProjectMembershipViewModel>(CanRemoveMember, RemoveMember);
ShowJoinDialogCommand = new DelegateCommand(CanJoinProject, ShowJoinDialog);
ShowContactListCommand = new DelegateCommand(ShowContactList);
SelectNewRoleCommand = new DelegateCommand<Role>(SelectNewRole);
membershipViewSource = new System.Windows.Data.CollectionViewSource();
membershipViewSource.SortDescriptions.Add(new SortDescription("SortPriority", ListSortDirection.Ascending));
membershipViewSource.SortDescriptions.Add(new SortDescription("ProjectMembership.Role.RoleName", ListSortDirection.Ascending));
membershipViewSource.SortDescriptions.Add(new SortDescription("Member.FullName", ListSortDirection.Ascending));
membershipViewSource.Filter += new System.Windows.Data.FilterEventHandler(membershipViewSource_Filter);
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);
aggregator.Subscribe<ICollection<Role>>(ScrumFactoryEvent.ProjectRolesChanged, roles => { OnPropertyChanged("Roles"); });
aggregator.Subscribe<Role>(ScrumFactoryEvent.ProjectRoleChanged, role => { membershipViewSource.View.Refresh(); });
aggregator.Subscribe(ScrumFactoryEvent.ShowProjectTeam, () => { aggregator.Publish<IProjectTabViewModel>(ScrumFactoryEvent.ShowProjectTab, this); });
// need thi when membership is removed from the project module
aggregator.Subscribe<ProjectMembership>(ScrumFactoryEvent.ProjectMembershipRemoved, AfterRemoveMember);
MemberCustomFilter = MemberFilter;
RefreshMemberFilter = LoadMembers;
}
public PendingMembershipsListViewModel(
[Import]IEventAggregator eventAggregator,
[Import]IProjectsService projectServices,
[Import]IBackgroundExecutor backgroundExecutor,
[Import]IAuthorizationService authorizationService)
{
this.aggregator = eventAggregator;
this.projectServices = projectServices;
this.executor = backgroundExecutor;
RefuseCommand = new DelegateCommand<ProjectMembership>(Refuse);
EngageCommand = new DelegateCommand<ProjectMembership>(Engage);
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);
}
public CreateRepositoryViewModel(
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator,
[Import] IDialogService dialogsService,
[Import] IProjectsService projectService)
{
this.aggregator = eventAggregator;
this.executor = backgroundExecutor;
this.dialogs = dialogsService;
this.projectService = projectService;
SetCodeRepCommand = new DelegateCommand<string>(SetCodeRep);
OpenCodeRepCommand = new DelegateCommand<string>(OpenCodeRep);
SaveCommand = new DelegateCommand(Save);
OnLoadCommand = new DelegateCommand(OnLoad);
}
public GroupListViewModel(
[Import] IBackgroundExecutor executor,
[Import] IEventAggregator aggregator,
[Import] IBacklogService backlogService,
[Import] IAuthorizationService authorizator)
{
this.executor = executor;
this.aggregator = aggregator;
this.backlogService = backlogService;
this.authorizator = authorizator;
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);
AddGroupCommand = new DelegateCommand(CanEditGroups, AddGroup);
UpdateGroupCommand = new DelegateCommand<BacklogItemGroup>(CanEditGroups, UpdateGroup);
}
public HourCostsViewModel(
[Import] IEventAggregator aggregator,
[Import] IBackgroundExecutor executor,
[Import] IAuthorizationService authorizator,
[Import] IDialogService dialogService,
[Import] IProposalsService proposalsService)
{
this.aggregator = aggregator;
this.executor = executor;
this.authorizator = authorizator;
this.dialogs = dialogService;
this.proposalsService = proposalsService;
this.ChangeCostsCommand = new DelegateCommand(ChangeCosts);
this.CancelCommand = new DelegateCommand(Cancel);
}
public RolesListViewModel(
[Import]IEventAggregator eventAggregator,
[Import]IProjectsService projectsServices,
[Import]IDialogService dialogs,
[Import]IBackgroundExecutor backgroundExecutor
)
{
this.aggregator = eventAggregator;
this.projectsServices = projectsServices;
this.executor = backgroundExecutor;
this.dialogs = dialogs;
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);
CloseWindowCommand = new DelegateCommand(CloseWindow);
AddNewRoleCommand = new DelegateCommand(AddNewRole);
DeleteRoleCommand = new DelegateCommand<RoleViewModel>(DeleteRole);
}
public IterationPlanningViewModel(
[Import] IBacklogService backlogService,
[Import] IProjectsService projectsService,
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IDialogService dialogService,
[Import] IEventAggregator eventAggregator,
[Import] IAuthorizationService authorizator)
{
this.projectsService = projectsService;
this.backlogService = backlogService;
this.executor = backgroundExecutor;
this.dialogs = dialogService;
this.aggregator = eventAggregator;
this.authorizator = authorizator;
SprintPlans = new ObservableCollection<SprintViewModel>();
aggregator.Subscribe<string>(ScrumFactoryEvent.ConfigChanged, OnConfigChanged);
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);
aggregator.Subscribe<ICollection<Sprint>>(ScrumFactoryEvent.SprintsDateChanged, OnSprintsDateChanged);
aggregator.Subscribe<BacklogItem[]>(ScrumFactoryEvent.BacklogItemsChanged, UpdateChangedItems);
aggregator.Subscribe<string>(ScrumFactoryEvent.BacklogItemDeleted, OnBacklogItemDeleted);
aggregator.Subscribe <ICollection<BacklogItemGroup>>(ScrumFactoryEvent.BacklogItemGroupsLoaded, OnBacklogItemsGroupLoaded);
LoadDataCommand = new DelegateCommand(() => { if (NeedRefresh) LoadData(); });
CreateNewSprintCommand = new DelegateCommand(CanEditSprints, CreateNewSprint);
EqualizeSprintsCommand = new DelegateCommand(CanEditSprints, EqualizeSprints);
RemoveSprintCommand = new DelegateCommand<SprintViewModel>(CanEditSprints, RemoveSprint);
MoveItemToCommand = new DelegateCommand<Windows.Helpers.DragDrop.DropCommandParameter>(MoveItemTo);
ShowDeliveryReportCommand = new DelegateCommand(ShowDeliveryReport);
ShowSprintStackReportCommand = new DelegateCommand(ShowSprintStackReport);
ShowFullDeliveryReportCommand = new DelegateCommand(ShowFullDeliveryReport);
ShiftItemsCommand = new DelegateCommand<BacklogItem>(CanEditSprints, ShiftItemsAfter);
ShowDetailCommand = new DelegateCommand<BacklogItemViewModel>(ShowDetail);
}
public DefaultReportViewModel(
[Import] IEventAggregator aggregator,
[Import] ReportHelper.Report reports,
[Import] IBackgroundExecutor executor,
[Import] IDialogService dialogs)
{
this.executor = executor;
this.aggregator = aggregator;
this.reports = reports;
this.dialogs = dialogs;
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, p => { Project = p; });
aggregator.Subscribe<ReportHelper.ReportConfig>(ScrumFactoryEvent.ShowReport, Show);
CloseWindowCommand = new DelegateCommand(CloseWindow);
RefreshCommand = new DelegateCommand(Refresh);
PrintCommand = new DelegateCommand(Print);
SaveAsCommand = new DelegateCommand(SaveAs);
}
public FinishTaskDialogViewModel(
[Import]IBackgroundExecutor executor,
[Import]IEventAggregator aggregator,
[Import]ITasksService tasksService,
[Import]IDialogService dialogs)
{
this.executor = executor;
this.aggregator = aggregator;
this.tasksService = tasksService;
this.dialogs = dialogs;
aggregator.Subscribe<Task>(ScrumFactoryEvent.ShowFinishTaskDialog, Show);
AddingHours = 0.0M;
FinishTaskCommand = new DelegateCommand(FinishTask);
CancelCommand = new DelegateCommand(() => { dialog.Close(); });
CopyTaskTrackIdCommand = new DelegateCommand(CopyTaskTrackId);
}
public CreateProjectViewModel(
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator,
[Import] IProjectsService projectService)
{
this.aggregator = eventAggregator;
this.executor = backgroundExecutor;
this.projectService = projectService;
aggregator.Subscribe<string>(ScrumFactoryEvent.ConfigChanged, c => {
if (c == "TicketProjectsEnabled")
OnPropertyChanged("IsTicketProjectsEnabled");
});
CreateProjectCommand = new DelegateCommand(CanCreateProject, CreateProject);
CloseWindowCommand = new DelegateCommand(() => { Close(); });
}
public ContactListViewModel(
[Import]IEventAggregator eventAggregator,
[Import]ITeamService teamServices,
[Import]IBackgroundExecutor backgroundExecutor,
[Import] IDialogService dialogs,
[Import]IAuthorizationService authorizationService)
{
this.aggregator = eventAggregator;
this.teamServices = teamServices;
this.executor = backgroundExecutor;
this.authorizator = authorizationService;
this.dialogs = dialogs;
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, p => { project = p; });
CloseWindowCommand = new DelegateCommand(CloseWindow);
AddNewContactCommand = new DelegateCommand(AddNewContact);
OnLoadCommand = new DelegateCommand(LoadData);
SendEmailCommand = new DelegateCommand<string>(SendEmail);
}
public RisksListViewModel(
[Import]IBackgroundExecutor executor,
[Import]IEventAggregator eventAggregator,
[Import]IDialogService dialogs,
[Import]IAuthorizationService authorizator,
[Import]IProjectsService projectsService)
{
this.executor = executor;
this.dialogs = dialogs;
this.aggregator = eventAggregator;
this.authorizator = authorizator;
this.projectsService = projectsService;
this.aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);
this.aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);
OnLoadCommand = new DelegateCommand(() => { if (NeedRefresh) LoadRisks(); });
AddRiskCommand = new DelegateCommand(CanAddRisk, AddRisk);
ShowDetailCommand = new DelegateCommand<RiskViewModel>(ShowDetail);
}
public MemberDetailBase(
IEventAggregator aggregator,
ITasksService tasksService,
IProjectsService projectsService,
ITeamService teamService,
IBackgroundExecutor executor,
IAuthorizationService authorizator)
{
this.aggregator = aggregator;
this.executor = executor;
this.authorizator = authorizator;
this.tasksService = tasksService;
this.teamService = teamService;
this.projectsService = projectsService;
ShowTaskDetailCommand = new DelegateCommand<Task>(ShowTaskDetail);
ShowProjectDetailCommand = new DelegateCommand<string>(ShowProjectDetail);
CloseTaskCommand = new DelegateCommand<Task>(CloseTask);
TrackTaskCommand = new DelegateCommand<Task>(TrackTask);
}
public MembersListViewModel(
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator,
[Import] IAuthorizationService authorizator,
[Import] IDialogService dialogService,
[Import] ITeamService teamService,
[Import] IProjectsService projectService)
{
this.aggregator = eventAggregator;
this.executor = backgroundExecutor;
this.authorizator = authorizator;
this.dialogs = dialogService;
this.teamService = teamService;
this.projectService = projectService;
membersViewSource = new System.Windows.Data.CollectionViewSource();
membersViewSource.SortDescriptions.Add(new SortDescription("MemberProfile.FullName", ListSortDirection.Ascending));
membersViewSource.Filter += new FilterEventHandler(membersViewSource_Filter);
delayFilter = new DelayAction(500, new DelayAction.ActionDelegate(() => { if (FilteredMembers != null) FilteredMembers.Refresh(); }));
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);
aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.ShowMemberDetail,
member => {
dialogs.SelectTopMenu(this);
ShowDetail(member);
});
OnLoadCommand = new DelegateCommand(() => { if (NeedRefresh) LoadMembers(); });
RefreshCommand = new DelegateCommand(LoadMembers);
ShowDetailWindowCommand = new DelegateCommand<MemberViewModel>(ShowDetail);
AddNewMemberCommand = new DelegateCommand(CanAddMember, AddMember);
OnlyActiveMembers = true;
NeedRefresh = true;
}
public HoursGraphViewModel(
[Import] IBacklogService backlogService,
[Import] IBackgroundExecutor backgroundExecutor,
[Import] IEventAggregator eventAggregator)
{
this.backlogService = backlogService;
this.executor = backgroundExecutor;
this.aggregator = eventAggregator;
NeedRefresh = false;
OnLoadCommand = new DelegateCommand(() => {if (NeedRefresh) LoadData();});
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, AskForRefresh);
aggregator.Subscribe<Project>(ScrumFactoryEvent.BurndownShouldRefresh, AskForRefresh);
aggregator.Subscribe<BacklogItem[]>(ScrumFactoryEvent.BacklogItemsChanged, b => { AskForRefresh(); });
EffectiveHours = new List<HourColumn>();
PlannedHours = new List<HourColumn>();
}
public ArtifactsListViewModel(
[Import] IAuthorizationService authorizator,
[Import] IArtifactsService artifactsService,
[Import] IEventAggregator aggregator,
[Import] IBackgroundExecutor executor)
{
this.authorizator = authorizator;
this.aggregator = aggregator;
this.executor = executor;
this.artifactsService = artifactsService;
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);
AddArtifactCommand = new DelegateCommand(CanAddArtifact, AddArtifact);
RemoveArtifactCommand = new DelegateCommand<string>(CanAddArtifact, RemoveArtifact);
GoToLinkCommand = new DelegateCommand<string>(GoToLink);
StartEditCommand = new DelegateCommand<string>(CanAddArtifact, StartEdit);
View = new ArtifactsList();
View.Model = this;
}
public ProposalViewModel(
[Import]IBackgroundExecutor executor,
[Import]IEventAggregator aggregator,
[Import]IDialogService dialogs,
[Import]IProposalsService proposalsService,
[Import]IProjectsService projectsService)
{
this.executor = executor;
this.aggregator = aggregator;
this.dialogs = dialogs;
this.proposalsService = proposalsService;
this.projectsService = projectsService;
aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);
itemsViewSource = new System.Windows.Data.CollectionViewSource();
itemsViewSource.SortDescriptions.Add(new SortDescription("ItemGroup.DefaultGroup", ListSortDirection.Ascending));
itemsViewSource.SortDescriptions.Add(new SortDescription("ItemGroup.GroupName", ListSortDirection.Ascending));
itemsViewSource.SortDescriptions.Add(new SortDescription("Item.Name", ListSortDirection.Ascending));
CloseWindowCommand = new DelegateCommand(CloseWindow);
RefreshProposalPriceCommand = new DelegateCommand(CanEdit, RefreshProposalPrice);
AddClauseCommand = new DelegateCommand(CanEdit, AddClause);
DeleteClauseCommand = new DelegateCommand<ProposalClause>(CanEdit, DeleteClause);
MoveClauseDownCommand = new DelegateCommand<ProposalClause>(CanEdit, MoveClauseDown);
MoveClauseUpCommand = new DelegateCommand<ProposalClause>(CanEdit, MoveClauseUp);
AddCostCommand = new DelegateCommand(CanEdit, AddFixedCost);
DeleteCostCommand = new DelegateCommand<ProposalFixedCost>(CanEdit, DeleteCost);
ApproveCommand = new DelegateCommand(CanEdit, Approve);
RejectCommand = new DelegateCommand<short>(CanEdit, Reject);
ShowProposalReportCommand = new DelegateCommand(ShowProposalReport);
SyncProposalDatesCommand = new DelegateCommand(SyncProposalDates);
}
