public ProductPreviewViewModel(IMessenger messenger, IBasketModel basketModel)
        {
            // Design setup
            if (this.IsInDesignMode)
            {
                Visible = true;

                Product = new Product()
                {
                    ProductId=12345,
                    Name = "Product Name",
                    Description = "Product Description",
                    UpdatedDate = DateTime.Today,
                };
            }

            // Unpack
            MessengerInstance = messenger;
            _basketModel = basketModel;

            // Register Message Handlers
            MessengerInstance.Register<ProductPreviewMessage>(this, HandleProductPreview);

            // Commands
            CloseCommand = new RelayCommand(CloseExecute);
            AddProductCommand = new RelayCommand(AddProductExecute);
        }

    public FileListingController(FileListingViewModel ViewModel, MainMenuViewModel MenuViewModel, IMessenger Messenger, IMapper Mapper, IUpkFileRepository Repository, IUpkFileRemoteRepository RemoteRepository) {
          viewModel = ViewModel;
      menuViewModel = MenuViewModel;

      messenger = Messenger;
         mapper = Mapper;

      repository = Repository;

      remoteRepository = RemoteRepository;

      viewModel.Files = new ObservableCollection<FileViewEntity>();

      viewModel.FilterText = String.Empty;

          viewModel.PropertyChanged += onViewModelPropertyChanged;
      menuViewModel.PropertyChanged += onMenuViewModelPropertyChanged;

      allFiles = new List<DomainUpkFile>();

      allFileEntities = new List<FileViewEntity>();

      registerMessages();
      registerCommands();
    }

        public ProjectPanelViewModel(ITrackerService svc, IMessenger mess)
        {
            _Messenger = mess;
            _Service = svc;

            Project = new ProjectViewModel();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainPageViewModel"/> class.
        /// </summary>
        /// <param name="messenger">
        /// The messenger.
        /// </param>
        /// <param name="navigationService">
        /// The navigation service.
        /// </param>
        public MainPageViewModel(IMessenger messenger, NavigationService navigationService)
            : base(messenger, navigationService)
        {
            this.InitializeMenu();

            this.ItemInvokedCommand = new RelayCommand<ListViewItem>(this.ItemInvoked);
        }

 public MessageController(IMessageService iMessageService, IUserInfo iUserInfo, IUnitOfWork unitOfWork, IMessenger iMessenger)
 {
     _iMessageService = iMessageService;
     _iUserInfo = iUserInfo;
     _unitOfWork = unitOfWork;
     _iMessenger = iMessenger;
 }

 public MainViewModel(IViewModelNavigator navigator, IMessenger messenger)
 {
     messenger.Register<ContentChangedMessage>(this, OnContentChanged);
     _messenger = messenger;
     _navigator = navigator;
     _navigator.NavigateForward<WelcomViewModel>(null);
 }

        public static UserPassword UserPasswordReset(string name, out string password, IMessenger messenger)
        {
            var user = UserPassword.FetchUserPassword(
                new UserPasswordCriteria
                    {
                        Name = name
                    });

            if (user != null)
            {
                password = PasswordHelper.GetRandomPassword(10);

                user.SetPassword(password);

                user = user.Save();

                if (messenger == null)
                {
                    messenger = MessageHelper.InitializeMessageForUserPasswordReset(user.Email);
                }

                messenger.Message = messenger.Message.Replace(MessageParameter.Password, password);

                messenger.Send();
            }
            else
            {
                throw new ArgumentException("No such user exists.");
            }

            return user;
        }

 protected ViewModelBaseEx( IViewServiceRepository viewServices = null, ISettingsRepository settingsRepo = null, IMessenger messenger = null )
 {
     MessengerInstance = messenger;
     ViewServices = viewServices ?? App.ViewServices;
     Session = App.Session;
     Settings = settingsRepo ?? App.Settings;
 }

        public LoginViewModel(IMessenger messenger, ILoginService loginService)
        {
            _messenger = messenger;
            _loginService = loginService;

            LoginCommand = new RelayCommand<object>(Login);
        }

    public UpkManagerController(UpkManagerViewModel ViewModel, MainMenuViewModel MenuViewModel, IMessenger Messenger, ISettingsRepository SettingsRepository, IExceptionRepository ExceptionRepository, IMapper Mapper) {
      if (Application.Current != null) Application.Current.DispatcherUnhandledException += onCurrentDispatcherUnhandledException;

      AppDomain.CurrentDomain.UnhandledException += onDomainUnhandledException;

      Dispatcher.CurrentDispatcher.UnhandledException += onCurrentDispatcherUnhandledException;

      TaskScheduler.UnobservedTaskException += onUnobservedTaskException;

      System.Windows.Forms.Application.ThreadException += onThreadException;

          viewModel =     ViewModel;
      menuViewModel = MenuViewModel;

      messenger = Messenger;

      settingsRepository  = SettingsRepository;
      exceptionRepository = ExceptionRepository;

      mapper = Mapper;

      settings = Task.Run(() => settingsRepository.LoadSettingsAsync()).Result;

      viewModel.Settings = mapper.Map<SettingsWindowViewEntity>(settings);

      registerMessages();
      registerCommands();
    }

        public Consolery(Type targetType, object target, string[] args, IMessenger messenger, Notation notationType)
        {
            Contract.Requires(targetType != null);
            Contract.Requires(args != null);
            Contract.Requires(messenger != null);

            _target = target;
            _targetType = targetType;
            _args = args;
            _messenger = messenger;

            _actionMethods = _targetType
                .GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance)
                .Where(method => method.GetCustomAttributes(false).OfType<ActionAttribute>().Any())
                .ToList();

            _metadata = new Metadata(_actionMethods);
            _metadataValidator = new MetadataValidator(_targetType, _actionMethods, _metadata);
            if (notationType == Notation.Windows)
            {
                _notation = new WindowsNotationStrategy(_args, _messenger, _metadata, _targetType, _actionMethods);
            }
            else
            {
                _notation = new LinuxNotationStrategy(_args, _messenger, _metadata);
            }
        }

        public CommonWindow(IMessenger messenger)
        {
            _messenger = messenger;
            _messenger.Register<CloseViewMessage>(this, Close);

            InitializeComponent();
        }

        public ChangePasswordView(IMessenger messenger)
        {
            InitializeComponent();

            _messenger = messenger;
            _messenger.Register<PasswordChangeMsg>(this, OnPasswordChangeMsgMessage);
        }

        public void Init()
        {
            var messengerMock = new Mock<IMessenger>();
            var serviceMock   = new Mock<ITrackerService>();

            _Messenger = messengerMock.Object;

            _MockPriorityList = new List<string>() { "High", "Low" };
            _MockStatusList = new List<string>() { "In Progress", "Closed" };

            _MockActiveProject = new ProjectViewModel(new Project { Id = 1, Code = "GGGGG", Description = "", Name = "TestProject" });

            _AssignedUserMock = new User() { Id = 5, FirstName = "Adam", Username = "adam", Password = "password" };

            _MockProjectUsersList = new List<User>() { _AssignedUserMock};

            serviceMock.Setup<List<string>>(p => p.GetBugPriorityList()).Returns(_MockPriorityList);
            serviceMock.Setup<List<string>>(p => p.GetBugStatusList()).Returns(_MockStatusList);
            serviceMock.Setup<List<User>>(p => p.GetUsersByProject(_MockActiveProject.ToProjectModel())).Returns(_MockProjectUsersList);
            serviceMock.Setup<User>(p => p.GetMyUser()).Returns(_AssignedUserMock);

            var _MockNotifier = new Mock<IGrowlNotifiactions>();

            _ServiceMock = serviceMock.Object;

            _ActiveProjectStub = new ProjectViewModel(new Project { Id = 5, Description = "Stub Project", Name = "Stub Title" });

            _AddPanel = new BugAddPanelViewModel(_Messenger, _ServiceMock, _MockActiveProject, _MockNotifier.Object);
        }

		public MovieGroupDetailViewModel(
			IMovieRepository movieRepository,
			IMessenger messenger)
		{
			MovieRepository = movieRepository;
			Messenger = messenger;
		}

        public MainViewModel(
            IViewModelNavigator navigator,
            IMessenger messenger,
            SessionService sessionService,
            CommunicationManager communicationManager,
            SettingsProvider settingsProvider)
        {
            _sessionService = sessionService;
            _communicationManager = communicationManager;
            _settingsProvider = settingsProvider;
            messenger.Register<ShowChildWindowMessage>(this, RaiseShowWindow);

            messenger.Register<WindowStateMessage>(this, state => RaiseStateChanged(state.State));

            messenger.Register<ContentChangedMessage>(this, OnContentChanged);
            //navigator.NavigateForward<WelcomeViewModel>(null); //temporary
            navigator.NavigateForward<PasswordPromptViewModel>(null);

            messenger.Register<CommandMessage>(this, OnOpenCommand);
            messenger.Register<CloseCommandMessage>(this, OnCloseCommand);
            UpdateSessionStart();
            communicationManager.Connect();
            _timer = new DispatcherTimer();
            _timer.Interval = new TimeSpan(0, 0, 15);
            _timer.IsEnabled = true;
            _timer.Tick += SendPing;
            _timer.Start();
        }

		public ProjectListViewModel( IViewServiceRepository viewServices = null, ISettingsRepository settingsRepo = null, IProjectRepository projectRepo = null, IMessenger messenger = null )
			: base( viewServices, settingsRepo, messenger )
		{
			ProjectRepo = projectRepo ?? new ProjectRepository( Session );

			Projects = new ObservableCollection<ProjectViewModel>( ProjectRepo.GetAll().OrderBy( p => p.Name ).Select( p => new ProjectViewModel( p ) ) );

			var last = Settings.GetById( SettingKeys.LastProject );
			CurrentProject = Projects.FirstOrDefault( p => p.Model.Id == last.Get<int>() ) ?? Projects.FirstOrDefault();

			foreach( var proj in Projects )
			{
				proj.CurrentChanged += Proj_CurrentChanged;
			}

			if( CurrentProject != null )
			{
				CurrentProject.IsCurrent = true;
			}

			ProjectNames = new List<string>();

			Validate( nameof( NewProjectName ) ).Check( () => !string.IsNullOrWhiteSpace( NewProjectName ) ).Message( Strings.ProjectMustHaveName );
			Validate( nameof( NewProjectName ) ).Check( () => !ProjectNames.Contains( NewProjectName ) ).Message( Strings.ThisNameIsAlreadyUsed );
			Reset();
		}

 public Playlist(IAudioPlayer player, ICurrentMixProvider mixProvider, IMessenger messenger)
 {
     if (mixProvider == null) throw new ArgumentNullException("mixProvider");
     if (messenger == null) throw new ArgumentNullException("messenger");
     this.player = player;
     this.mixProvider = mixProvider;
 }

        public SessionManagerMonkey(IMessenger messenger, UserTaskRepository taskRepository)
        {
            this.messenger = messenger;
            this.taskRepository = taskRepository;

            messenger.Register<CreateUserTaskMessage>(this, HandleUserTaskCreatedMessage);
        }

		private Consolery(Type targetType, string[] args, IMessenger messenger)
		{
			#region Parameter Validation

			if (targetType == null)
			{
				throw new ArgumentNullException("targetType");
			}
			if (args == null)
			{
				throw new ArgumentNullException("args");
			}
			if (messenger == null)
			{
				throw new ArgumentNullException("messenger");
			}

			#endregion

			m_TargetType = targetType;
			m_Args = args;
			m_Messenger = messenger;
			MethodInfo[] methods = m_TargetType.GetMethods(BindingFlags.Public | BindingFlags.Static);
			foreach (MethodInfo method in methods)
			{
				object[] attributes = method.GetCustomAttributes(false);
				if (attributes.OfType<ActionAttribute>().Any())
				{
					m_ActionMethods.Add(method);
				}
			}
		}