public ViewModelCrew()
        {
            if (Client.State == CommunicationState.Closed)
            {
                Client.Open();
            }

            crew = new Crew();

            AddEntityCommand = new RelayCommand(AddEntityCommand_Execute, AddEntityCommand_CanExecute);
            RemoveEntityCommand = new RelayCommand(RemoveEntityCommand_Execute, RemoveEntityCommand_CanExecute);
            AddToCrewCommand = new RelayCommand(AddToCrewCommand_Execute, AddToCrewCommand_CanExecute);
            RemoveFromCrewCommand = new RelayCommand(RemoveFromCrewCommand_Execute, RemoveFromCrewCommand_CanExecute);
            AddAllCommand = new RelayCommand(AddAllCommand_Execute, AddAllCommand_CanExecute);
            RemoveAllCommand = new RelayCommand(RemoveAllCommand_Execute, RemoveAllCommand_CanExecute);

            Crews = new ObservableCollection<Crew>(Client.GetEntityByType(EntityType.Crew).Cast<Crew>());
            AllMembers = new ObservableCollection<CrewMember>(Client.GetEntityByType(EntityType.CrewMember).Cast<CrewMember>().Where(member => string.IsNullOrEmpty(member.Crew)));
            CrewMembers = new ObservableCollection<CrewMember>();
            SelectedMembers = new ObservableCollection<CrewMember>();
            SelectedMembersToRemove = new ObservableCollection<CrewMember>();

            MakeProxy(this);

            try
            {
                proxy.Subscribe(EntityType.Crew.ToString());
                proxy.Subscribe(EntityType.CrewMember.ToString());
            }
            catch (Exception ex)
            {
                CrFSMLogger.CrFSMLogger.Instance.WriteToLog(ex);
            }
        }

 /// <summary>
 /// Default constructor.  We set the initial view-model to 'FirstViewModel'.
 /// We also associate the commands with their execution actions.
 /// </summary>
 public MainViewModel()
 {
     CurrentViewModel = MainViewModel._firstViewModel;
     ViewRSSFeedCommand = new RelayCommand(param => ExecuteViewRSSFeedCommand());
     SettingViewCommand = new RelayCommand(param => ExecuteSettingViewCommand());
     SearchRSSViewCommand = new RelayCommand(param => ExecuteSearchRSSViewCommand());
 }

        public MainWindowViewModel(IDialogService dialogService)
        {
            this.dialogService = dialogService;

            ImplicitShowDialogCommand = new RelayCommand(ImplicitShowDialog);
            ExplicitShowDialogCommand = new RelayCommand(ExplicitShowDialog);
        }

        public PlayersViewModel()
        {
            Players = new ObservableCollection<Player>();

            #region RCON Events
            App.ArkRcon.PlayersUpdated += async (s, args) =>
            {
                Players.Clear();
                foreach (Ark.Models.Player player in args.Players)
                {
                    Players.Add(new Models.Player(player));
                }
                await UpdateSteamPlayerInfo();
            };
            #endregion
            
            #region Buttons and Events

            OpenSteamProfileCommand = new RelayCommand(OpenSteamProfile);
            CopySteamIDCommand = new RelayCommand(CopySteamID);
            CopyPlayerNameCommand = new RelayCommand(CopyPlayerName);
            KickSelectedCommand = new RelayCommand(KickSelectedPlayer);
            BanSelectedCommand = new RelayCommand(BanSelectedPlayer);
            WhitelistSelectedCommand = new RelayCommand(WhitelistSelectedPlayer);
            UnWhitelistSelectedCommand = new RelayCommand(UnWhitelistSelectedPlayer);
            PMSelectedPlayerCommand = new RelayCommand(PMSelectedPlayer);
            RefreshPlayersCommand = new RelayCommand(RefreshPlayers);
            
            #endregion

            PrivateMessage = string.Empty;

        }

        public CustomerListViewModel()
        {
            if (DesignerProperties.GetIsInDesignMode(new System.Windows.DependencyObject())) return;

            //Customers = new ObservableCollection<Customer>(_customersRepo.GetCustomersAsync().Result);
            DeleteCommand = new RelayCommand(OnDelete, CanDelete);
        }

        //Constructor 
        public BaseViewModel() {

            CloseWindowCommand = new RelayCommand<Window>(CloseWindow);

            UndoCommand = new RelayCommand(undoRedoController.Undo, undoRedoController.CanUndo);
            RedoCommand = new RelayCommand(undoRedoController.Redo, undoRedoController.CanRedo);

            CutCommand = new RelayCommand(Cut, LampsAreSelected);
            CopyCommand = new RelayCommand(Copy, LampsAreSelected);
            PasteCommand = new RelayCommand(Paste);

            AddLampCommand = new RelayCommand<IList>(AddNewLamp);
            RemoveLampCommand = new RelayCommand(RemoveLamp, LampsAreSelected);

            dialogWindow = new DialogViews();
            NewDrawingCommand = new RelayCommand(NewDrawing);
            LoadDrawingCommand = new RelayCommand(LoadDrawing);
            SaveDrawingCommand = new RelayCommand(SaveDrawing);
            SaveAsDrawingCommand = new RelayCommand(SaveAsDrawing);
        
            LightSwitchCommand = new RelayCommand(LightSwitch);
            SwitchLampLightCommand = new RelayCommand(singleLampLightSwitch, LampsAreSelected);

            toggleSnappingCommand = new RelayCommand(toggleSnapping);
            toggleGridVisibilityCommand = new RelayCommand(toggleVisibility);
        }

        public TranslationAdornment(SnapshotSpan span, TranslationRequest request, Size viewportSize)
        {
            Span = span.Snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive);
            Request = request;
            Request.TranslationComplete += request_TranslationComplete;

            InitializeComponent();
            DataContext = this;

            SetMaxSize(viewportSize);

            _menu = spListBox.ContextMenu;
            _menu.KeyUp += (sender, args) =>
            {
                if (args.Key == Key.Left || args.Key == Key.Escape)
                {
                    CloseMenu();
                }
            };
            _menu.Opened += (sender, args) => { _closeMenuRequested = false; };
            _menu.Closed += (sender, args) => { _ignoreItemCommand = !_closeMenuRequested; };

            ItemCommand = new RelayCommand<ItemCommandParameter>(ItemCommandExecute);
            ItemOptionsCommand = new RelayCommand<ItemCommandParameter>(ItemOptionsCommandExecute);
            MenuCommand = new RelayCommand<MenuItem>(MenuCommandExecute);
        }

 public SearchViewModel(ISearchService searchService)
 {
     this.searchService = searchService;
     Search = new RelayCommand(SearchExecuted);
     ShowDetails = new RelayCommand<SearchResult>(ShowDetailsExecuted);
     Results = new List<SearchResult>();
 }

        public IntroductionViewModel(GenericDataAccess<string> dataAccess)
        {
            this.dataAccess = dataAccess;
            introduction = dataAccess.TryLoad();

            SaveCommand = new RelayCommand<object>(_ => Save());
        }

 public TerminalWindowViewModel()
     : base()
 {
     HomeCommand = new RelayCommand(Home);
     SearchServiceCommand = new RelayCommand(SearchService);
     UnloadedCommand = new RelayCommand(Dispose);
 }

        public ViewModel_MainWindow()
        {
            if (!DesignerProperties.GetIsInDesignMode(Application.Current.MainWindow))
            {
                this.TrackDetails.Title = "Initializing Spotify ...";
                if (Wrapper_Spotify.Init())
                {
                    Wrapper_Skype.Init();

                    Updater.I.Start();
                    StatusEffects.I.Start();

                    NameEffect.I.Start();
                    NameEffect.I.UpdateEffect(2);
                    NameEffect.I.UpdateTrackDetails("Jayson Ragasa ");

                    Wrapper_Spotify.TrackChanged += Wrapper_Spotify_TrackChanged;

                    Command_Update = new RelayCommand(Commnad_Update_Click);

                    this.Pattern = Properties.Settings.Default.Pattern;
                    this.SelectedEffect = Properties.Settings.Default.SelectedEffect;
                }
                else
                {
                    this.TrackDetails.Title = "Make sure you're running Spotify. Please restart this app";
                    Process.GetCurrentProcess().Kill();
                }
            }
        }

 /// <summary>
 /// Register commands
 /// </summary>
 private void RegisterCommands()
 {
     StopPlayingMediaCommand = new RelayCommand(() =>
     {
         Messenger.Default.Send(new StopPlayingMovieMessage());
     });
 }

 public AllSongsViewModel()
 {
     GoBackCommand = new RelayCommand(GoBack);
     AddToQueueCommand = new RelayCommand(AddToQueue);
     PlayCommand = new RelayCommand(Play);
     SongHits = (List<Song>)NavigationService.GetInstance().Content;   
 }

		public UserPageViewModel()
		{
			Title = "Пользователи";
			Users = new ObservableCollection<CheckedItemViewModel<User>>(ClientManager.SecurityConfiguration.Users.Select(item => new CheckedItemViewModel<User>(item)));
			SelectAllCommand = new RelayCommand(() => Users.ForEach(item => item.IsChecked = true));
			SelectNoneCommand = new RelayCommand(() => Users.ForEach(item => item.IsChecked = false));
		}

        public PlanSchematicViewModel(RoadwayModel_TabVM parentVM)
            : base()
        {
            parentVM_ = parentVM;
             if (parentVM_ == null) return;

             isPortWindowMoving = false;
             startMovingPoint.X = startMovingPoint.Y = 0.0;

             currentCorridor_ = parentVM_.CurrentCorridor;
             ViewScaleFeetPerInch = 100.0;
             currentCorridor_ = parentVM_.CurrentCorridor;
             AdvanceDistance = 20.0;

             AdvanceStationAheadCmd = new RelayCommand(advanceStationAhead, () => canAdvanceAhead);
             canAdvanceAhead = true;

             AdvanceStationBackCmd = new RelayCommand(advanceStationBack, () => canAdvanceBack);
             canAdvanceBack = true;

             WindowCenterY = 2000.0;

             PlanStation = "";
             PlanOffset = "";
             PlanElevation = "";
             PlanCrossSlope = "";
        }

        public BluetoothConnectionManager()
        {
            BluetoothCancelCommand = new RelayCommand(AbortConnection);
            BluetoothDisconnectCommand = new RelayCommand(Disconnect);
            //reader = new DataReader(socket.InputStream);

        }

 public SwitchLanguageViewModel()
 {
     LangList = StaticDatas.GetLanguageList();
     loadConfigValue();
     ConfirmCommand = new RelayCommand(OnExecuteConfirmCommand, OnCanExecuteConfirmCommand);
     CancelCommand = new RelayCommand(OnExecuteCancelCommand);
 }

        public SuppliersListViewModel()
        {
            if (DesignerProperties.GetIsInDesignMode(
                new System.Windows.DependencyObject())) return;

            try
            {
                var suppliers = db.Suppliers.Include(s => s.Suburb);
                Suppliers = new ObservableCollection<Supplier>(suppliers.ToList());
            }
            catch (Exception ex)
            {
                logger.Error(ex.Message.ToString());
            }
            try
            {
                var suburbs = db.Suburbs.ToList();
                Suburbs = new ObservableCollection<Suburb>(suburbs);
            }
            catch (Exception ex)
            {
                logger.Error(ex.Message.ToString());
            }

            _newSupplier = new Supplier();
            _searchResults = new ObservableCollection<Supplier>();

            DeleteSupplierCommand = new RelayCommand<Supplier>(onDeleteSupplier);
            UpdateSupplierCommand = new RelayCommand<Supplier>(onUpdateSupplier);
            AddSupplierCommand = new RelayCommand<Supplier>(onAddSupplier);
            FindSuppliersCommand = new RelayCommand<string>(onFindSuppliers);
        }

        /// <summary>
        /// For designer only
        /// </summary>
        public SimpleTextCaptureViewModel()
        {
            RefreshCommand = new RelayCommand(Refresh);

            Packets.Add(new PacketViewModel(new byte[]{ 1, 2, 3, 4, 5 }));
            Packets.Add(new PacketViewModel(new byte[] { 1, 2, 3, 4, 5 }));
        }

        public AdminVM()
        {
            // Commands:
            AdminLoginCommand = new RelayCommand(DoAdminLogin);
            CloseApplicationCommand = new RelayCommand(CloseApplication);
            AdminChangePasswordCommand = new RelayCommand(ChangeAdminPassword);
            ShowChangePasswordCommand = new RelayCommand(ShowChangePassword);

            // Admin Commands for users
            DeleteSelectedUserCommand = new RelayCommand<User>(DeleteSelectedUser);
            AddNewUserCommand = new RelayCommand(AddNewUser);
            ShowLogForUser = new RelayCommand<User>(UserShowLog);

            // Admin Commands for products
            DeleteSelectedProductCommand = new RelayCommand<Product>(DeleteSelectedProduct);
            AddNewProductCommand = new RelayCommand(AddNewProduct);
            ShowLogForProduct = new RelayCommand<Product>(ProductShowLog);

            // Log commands:
            ShowFullUserLogCommand = new RelayCommand(ShowUsersLog);
            ShowFullAdminLogCommand = new RelayCommand(ShowAdminLog);
            ShowFullTransactionLogCommand = new RelayCommand(ShowTransactionsLog);

            // Admin commands for Load, Save and New
            SaveDataCommand = new RelayCommand(SaveCurrentData);
            LoadDataCommand = new RelayCommand(LoadExistingData);
            NewDataCommand = new RelayCommand(NewData);
            GenerateBillCommand = new RelayCommand(GenerateBill);
        }