public PlaylistProvider(
            ISession session, 
            Dispatcher dispatcher,
            ILoggerFacade logger)
        {
            _session = session;
            _dispatcher = dispatcher;
            _logger = logger;
            _playlists = new ObservableCollection<Playlist>();

            if (_session.PlaylistContainer != null)
            {
                InitializePlaylistContainer();
            }
            else
            {
                _session.LoginComplete += (s, e) =>
                                              {
                                                  if (e.Status == Error.OK)
                                                  {
                                                      InitializePlaylistContainer();
                                                  }
                                              };
            }
        }

        public TransferViewModel(
            ILoggerFacade logger,
            IStatusBar statusBar,
            IRegionManager regionManager,
            IEventAggregator eventAggregator,
            ITradingServiceAsync tradingService,
            Bullsfirst.InterfaceOut.Oms.MarketDataServiceReference.IMarketDataServiceAsync marketDataService,
            UserContext userContext,
            ReferenceData referenceData)
        {
            logger.Log("TransferViewModel.TransferViewModel()", Category.Debug, Priority.Low);
            _logger = logger;
            _statusBar = statusBar;
            _regionManager = regionManager;
            _eventAggregator = eventAggregator;
            _tradingService = tradingService;
            _marketDataService = marketDataService;
            this.UserContext = userContext;
            this.ReferenceData = referenceData;

            _tradingService.TransferCashCompleted += new EventHandler<AsyncCompletedEventArgs>(TransferCallback);
            _tradingService.TransferSecuritiesCompleted += new EventHandler<AsyncCompletedEventArgs>(TransferCallback);
            _tradingService.AddExternalAccountCompleted += new EventHandler<AddExternalAccountCompletedEventArgs>(AddExternalAccountCallback);
            _marketDataService.GetMarketPriceCompleted +=
                new EventHandler<InterfaceOut.Oms.MarketDataServiceReference.GetMarketPriceCompletedEventArgs>(GetMarketPriceCallback);
            TransferCommand = new DelegateCommand<object>(this.TransferExecute, this.CanTransferExecute);
            AddExternalAccountCommand = new DelegateCommand<object>(this.AddExternalAccountExecute);
            this.PropertyChanged += this.OnPropertyChanged;
            this.ValidateAll();

            SubscribeToEvents();
        }

        public AccountsViewModel(
            ILoggerFacade logger,
            IStatusBar statusBar,
            IRegionManager regionManager,
            IEventAggregator eventAggregator,
            ITradingServiceAsync tradingService,
            UserContext userContext)
        {
            logger.Log("AccountsViewModel.AccountsViewModel()", Category.Debug, Priority.Low);
            _logger = logger;
            _statusBar = statusBar;
            _regionManager = regionManager;
            _eventAggregator = eventAggregator;
            _tradingService = tradingService;
            this.UserContext = userContext;

            _tradingService.OpenNewAccountCompleted += new EventHandler<OpenNewAccountCompletedEventArgs>(OpenNewAccountCallback);
            _tradingService.ChangeAccountNameCompleted += new EventHandler<AsyncCompletedEventArgs>(ChangeAccountNameCallback);
            CreateAccountCommand = new DelegateCommand<object>(this.CreateAccountExecute);
            EditAccountCommand = new DelegateCommand<object>(this.EditAccountExecute);
            UpdateAccountsCommand = new DelegateCommand<object>(this.UpdateAccountsExecute);
            SelectAccountCommand = new DelegateCommand<object>(this.SelectAccountExecute);

            SubscribeToEvents();
        }

 public LocationInputViewModel(CompositionContainer container, ILoggerFacade loggerFacade, IEventAggregator eventAggregator)
 {
     this.Street = string.Empty;
     this.Number = string.Empty;
     this.City = string.Empty;
     this.PostCode = string.Empty;
     this.OkCommand = new DelegateCommand<object>(
     this.OnOKClicked, this.CanOKClicked);
     this.CancelCommand = new DelegateCommand<object>(
     this.OnCancelClicked, this.CanCancelClicked);
     this.MoveDownStopCommand = new DelegateCommand<object>(
     this.OnMoveDownCommand, this.CanMoveDownCommand);
     this.MoveUpStopCommand = new DelegateCommand<object>(
     this.OnMoveUpCommand, this.CanMoveUpCommand);
     this.DeleteStopCommand = new DelegateCommand<object>(
     this.OnDeleteStopCommand, this.CanDeleteStopCommand);
     this._container = container;
     this._loggerFacade = loggerFacade;
     this.eventAggregator = eventAggregator;
     mainTabEvent = eventAggregator.GetEvent<CompositePresentationEvent<MainTabInfo>>();
     _notificationErrorInteraction = new InteractionRequest<Notification>();
     this.LocationSelectedCommand = new DelegateCommand<object>(
     this.OnLocationSelected, this.CanLocationSelected);
     this.StopSelectedCommand = new DelegateCommand<object>(
     this.OnStopSelected, this.CanStopSelected);
     this.LocationsSelected = new ObservableCollection<GeoLocatorDetail>();
     this.LocationResults = new ObservableCollection<GeoLocatorDetail>();
     this.RouteDirections = new ObservableCollection<string>();
     this.SelectionVisibility = Visibility.Visible;
     this.StopsVisibility = Visibility.Collapsed;
     this.RouteDirectionsVisibility = Visibility.Collapsed;
 }

 public DataRepositoryObjectViewModel( IDataRepository dataRepository, IRegionManager regionManager, IInteractionService interactionService, ILoggerFacade logger )
     : base(regionManager, interactionService, logger)
 {
     Model = null;
      InTransaction = false;
      this.DataRepository = dataRepository;
 }

 public static ILoggerFacade InitLog4Net(string logName)
 {
     if (m_logger == null) {
         m_logger = new Log4NetLogger(logName);
     }
     return m_logger;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="RosterViewModel"/> class.
        /// </summary>
        /// <param name="eventAggregator">The event aggregator.</param>
        /// <param name="logger">The logger.</param>
        /// <param name="rosterService">The roster service.</param>
        public RosterViewModel(IEventAggregator eventAggregator, ILoggerFacade logger, RosterService rosterService)
        {
            this.RosterService = rosterService;
            this.RegisterHandlers();

            logger.Log("RosterViewModel Initialized", Category.Debug, Priority.None);
        }

 public ClientsViewModel(IEventAggregator aggregator, IRegionManager regionManager,
     IConnectionManager connectionManager, IInteractionService interactionService, ILoggerFacade loggerFacade) :
         base(aggregator, regionManager, connectionManager, interactionService, loggerFacade)
 {
     //aggregator.GetEvent<BootstrappingCompleteUiEvent>().Subscribe(BootstrappCompletedHandler);
     AdditionalRoomsValues = new ObservableCollection<string> {"Yes", "No"};
 }

 public ReservationModule(IUnityContainer container, IRegionManager regionManager, IEventAggregator eventAggregator, ILoggerFacade logger)
 {
     this._container = container;
     this._regionManager = regionManager;
     this._eventAggregator = eventAggregator;
     this._logger = logger;
 }

        public OrdersViewModel(
            ILoggerFacade logger,
            IStatusBar statusBar,
            IEventAggregator eventAggregator,
            ITradingServiceAsync tradingService,
            UserContext userContext,
            ReferenceData referenceData)
        {
            logger.Log("PositionsViewModel.PositionsViewModel()", Category.Debug, Priority.Low);
            _logger = logger;
            _statusBar = statusBar;
            _eventAggregator = eventAggregator;
            _tradingService = tradingService;
            this.UserContext = userContext;
            this.Orders = new ObservableCollection<Order>();
            this.ReferenceData = referenceData;

            this.UpdateOrdersCommand = new DelegateCommand<object>(this.UpdateOrdersExecute);
            this.ResetFilterCommand = new DelegateCommand<object>(this.ResetFilterExecute);
            this.CancelOrderCommand = new DelegateCommand<object>(this.CancelOrderExecute);

            _tradingService.GetOrdersCompleted +=
                new EventHandler<GetOrdersCompletedEventArgs>(GetOrdersCallback);
            _tradingService.CancelOrderCompleted +=
                new EventHandler<AsyncCompletedEventArgs>(CancelOrderCallback);
            this.UserContext.PropertyChanged +=
                new PropertyChangedEventHandler(OnUserContextPropertyChanged);

            ResetFilter();
            SubscribeToEvents();
        }

 public MefModuleManager(
     IModuleInitializer moduleInitializer,
     IModuleCatalog moduleCatalog,
     ILoggerFacade loggerFacade)
     : base(moduleInitializer, moduleCatalog, loggerFacade)
 {
 }

 /// <summary>
 ///     Initializes a new instance of the <see cref="VMBase" /> class.
 /// </summary>
 /// <param name="aggregator">The aggregator.</param>
 /// <param name="regionManager">The region manager.</param>
 /// <param name="connectionManager"></param>
 /// <param name="interactionService"></param>
 /// <param name="loggerFacade"></param>
 /// <exception cref="System.ArgumentNullException">
 ///     Any parameter
 /// </exception>
 public ApplicationMenuViewModel(IEventAggregator aggregator, IRegionManager regionManager,
     IConnectionManager connectionManager,
     IInteractionService interactionService, ILoggerFacade loggerFacade)
     : base(aggregator, regionManager, connectionManager, interactionService, loggerFacade)
 {
     EventAggregator.GetEvent<UserAuthCompletedEvent>().Subscribe(OnUserAuth);
 }

 public BaseIOViewModel(SelectedSettings settings, string portName, ILoggerFacade logger)
 {
     this.logger = logger;
     this.settings = settings;
     this.portName = portName;
     StopCommand = new DelegateCommand(OnStop);
 }

 public CustomerListViewModel(IUnityContainer container)
 {
   this.container = container;
   this.logger = this.container.Resolve<ILoggerFacade>();
   this.eventAggregator = this.container.Resolve<IEventAggregator>();
   this.modelService = this.container.Resolve<IModelService>();
 }

        protected PrismUnityApplication(ILoggerFacade logger, IUnityContainer container) : base(logger)
        {
            if (container == null)
                throw new InvalidOperationException("Unity container is null");

            Container = container;
        }

        public ModuleBModule(IRegionManager regionManager, ILoggerFacade logger)
        {
            _regionManager = regionManager;
            _logger = logger;

            _logger.Log("ModuleBModule.ctor() [done]", Category.Debug, Priority.Low);
        }

        public TransactionHistoryViewModel(
            ILoggerFacade logger,
            IStatusBar statusBar,
            IEventAggregator eventAggregator,
            ITradingServiceAsync tradingService,
            UserContext userContext)
        {
            logger.Log("TransactionHistoryViewModel.TransactionHistoryViewModel()", Category.Debug, Priority.Low);
            _logger = logger;
            _statusBar = statusBar;
            _eventAggregator = eventAggregator;
            _tradingService = tradingService;
            this.UserContext = userContext;
            this.Transactions = new ObservableCollection<TransactionSummary>();

            this.UpdateTransactionsCommand = new DelegateCommand<object>(this.UpdateTransactionsExecute);
            this.ResetFilterCommand = new DelegateCommand<object>(this.ResetFilterExecute);

            _tradingService.GetTransactionSummariesCompleted +=
                new EventHandler<GetTransactionSummariesCompletedEventArgs>(GetTransactionSummariesCallback);
            this.UserContext.PropertyChanged +=
                new PropertyChangedEventHandler(OnUserContextPropertyChanged);

            ResetFilter();
            SubscribeToEvents();
        }

 public ReservationManager(ILoggerFacade logger, IReservationDataService reservationDataService)
 {
     this._logger = logger;
     this._reservationDataService = reservationDataService;
     this._reservationDataService.Serializer = new XmlSerializer(typeof(Reservation));
     this._reservationCollection = new ObservableCollection<Reservation>();
 }

        protected BaseViewModel(ILoggerFacade logger)
        {
            Requires.NotNull(logger, "logger");
            _logger = logger;

            Disposed = false;
        }

        public ReservationDashBoardViewModel(IUnityContainer container, ILoggerFacade logger, IReservationManager reservationManager, ITableManager tableManager, IMessageBoxService messageBoxService, IDialogBoxService dialogBoxService)
        {
            this._logger = logger;
            this._container = container;
            this._reservationManager = reservationManager;
            this._tableManager = tableManager;
            this._messageBoxService = messageBoxService;
            this._dialogBoxService = dialogBoxService;
            this._reservationHours = new ObservableCollection<ReservationHour>();
            this._reservations = new MappedValueCollection();


            this.AddCommand = new DelegateCommand(this.OnAddCommand, () => { return this._noOfPersons > 0; });
            this.BrowseCommand = new DelegateCommand(this.OnBrowseCommand);
            this.ImportCommand = new DelegateCommand(this.OnImportCommand, () => { return !string.IsNullOrEmpty(this._tableXMLFile); });

            this._tables = this._tableManager.GetAll();
            
            // Assumption : Reservation duration is between 10 Am and 10 Pm
            this._minFromHour = 10;
            this._maxFromHour = 22;

            for (int hour = this._minFromHour; hour <= this._maxFromHour; hour++)
            {
                this._reservationHours.Add(new ReservationHour(hour));
            }

            this.FromHour = this._minFromHour;

            TableReservation.Common.ReservationsUpdatedEvent.Instance.Subscribe(this.ReservationsUpdated);
            this.ReservationsUpdated(Guid.NewGuid());
        }