public void LoadSaveGame_FileNotFound_ReturnsFileNotFoundErrorText(
            [Frozen] IMainModel model,
            [Frozen] IBackupService backupService,
            [Frozen] IRemoveWaggonsService removeWaggonsService,
            [Frozen] IMoveObjectsService moveObjectsService,
            [Frozen] IMoveTracksService moveTracksService,
            [Frozen] IMoveWaggonsService moveWaggonsService,
            string filePath
            )
        {
            //Arrange

            var mockedFileSystem = new MockFileSystem();

            model.FileName.Returns(filePath);
            var sut = new SavegameService(model, backupService, removeWaggonsService, moveObjectsService, moveTracksService, moveWaggonsService, mockedFileSystem);

            //Act
            var result = sut.LoadSavegame();

            result.Should().Be($"Error: File {filePath} not Found.");
            model.FileContent.Should().BeEmpty();

            backupService.ReceivedCalls().Should().BeEmpty();
            removeWaggonsService.ReceivedCalls().Should().BeEmpty();
        }
        public MainViewModel(IMainModel mainModel, INavigationService navigationService, IEmailComposeService emailComposeService, ISmsComposeService smsComposeService, IShareStatusService shareStatusService)
        {
            _mainModel           = mainModel;
            _navigationService   = navigationService;
            _emailComposeService = emailComposeService;
            _smsComposeService   = smsComposeService;
            _shareStatusService  = shareStatusService;

            PreviousQuoteCommand = new RelayCommand(OnPreviousQuoteCommand,
                                                    () => _mainModel.SelectedIndex > 0);

            NextQuoteCommand = new RelayCommand(OnNextQuoteCommand,
                                                () => _mainModel.SelectedIndex < _mainModel.Quotes.Length - 1);

            RandomQuoteCommand = new RelayCommand(OnRandomQuoteCommand);

            TodaysQuoteCommand = new RelayCommand(OnTodaysQuoteCommand);

            ShowAboutCommand = new RelayCommand(OnShowAboutCommand);

            ShareByEmailCommand = new RelayCommand(OnShareByEmailCommand);

            ShareBySmsCommand = new RelayCommand(OnShareBySmsCommand);

            ShareOnSocialNetworkCommand = new RelayCommand(OnShareOnSocialNetworkCommand);
        }
        public void LoadSaveGame_FileCanBeReadWithoutError_ReturnsEmptyString(
            [Frozen] IMainModel model,
            [Frozen] IBackupService backupService,
            [Frozen] IRemoveWaggonsService removeWaggonsService,
            [Frozen] IMoveObjectsService moveObjectsService,
            [Frozen] IMoveTracksService moveTracksService,
            [Frozen] IMoveWaggonsService moveWaggonsService,
            string fileContent,
            string filePath
            )
        {
            //Arrange

            var mockedFileSystem  = new MockFileSystem();
            var mockedFileContent = new MockFileData(fileContent);

            mockedFileSystem.AddFile(filePath, mockedFileContent);
            model.FileName.Returns(filePath);
            var sut = new SavegameService(model, backupService, removeWaggonsService, moveObjectsService, moveTracksService, moveWaggonsService, mockedFileSystem);

            //Act
            var result = sut.LoadSavegame();

            result.Should().BeEmpty();
            model.FileContent.Should().Be(fileContent);

            backupService.ReceivedCalls().Should().BeEmpty();
            removeWaggonsService.ReceivedCalls().Should().BeEmpty();
        }
示例#4
0
        public void Run()
        {
            try
            {
#if DEBUG
                LogHelper.TryReconfigureLoggerToLevel(LogLevel.Debug);
#endif
                IContainer autofacContiner = AutofacConfigurator.Configure(_logger);

                using (ILifetimeScope scope = autofacContiner.BeginLifetimeScope())
                {
                    IMainViewModel mainWindowViewModel = scope.Resolve <IMainViewModel>();
                    IMainModel     mainWindowModel     = scope.Resolve <IMainModel>(TypedParameter.From(mainWindowViewModel));
                    Window         mainWindow          = new MainWindow(mainWindowViewModel);
                    Application    application         = new Application();

                    AppDomain.CurrentDomain.UnhandledException += _currentDomainOnUnhandledExceptionEventHandler;
                    TaskScheduler.UnobservedTaskException      += _taskSchedulerOnUnobservedTaskExceptionEventHandler;
                    application.Dispatcher.UnhandledException  += _dispatcherOnUnhandledExceptionEventHandler;
                    application.Exit  += _applicationExitEventHandler;
                    mainWindow.Closed += _mainWindowClosedEventHandler;

                    application.Run(mainWindow);
                }
            }
            catch (Exception exception)
            {
                HandleException(exception);
            }
        }
        public static IContainer Configure(ILogger logger)
        {
            var builder = new ContainerBuilder();

            builder.Register(context =>
            {
                ILogFolder logFolder = context.Resolve <ILogFolder>();
                IMainModel model     = MainModel.Create(logFolder, logger);
                return(model);
            }).As <IMainModel>();

            builder.Register(context =>
            {
                IMainModel mainModel = context.Resolve <IMainModel>();
                IMainViewModel mainWindowViewModel = new MainViewModel(mainModel, logger);
                return(mainWindowViewModel);
            }).As <IMainViewModel>();

            builder.Register(context =>
            {
                ILogFolder logFolder = new LogFolder();
                return(logFolder);
            }).As <ILogFolder>();


            IContainer container = builder.Build();

            return(container);
        }
示例#6
0
        public MainViewModel(IMainModel model)
        {
            this.model = model;

            model.notifyPropertyChanged += (object sender, EventArgs e) => {
                if (e as CSVAnomaliesFileUploadEventArgs != null)
                {
                    CSVAnomaliesFileUploadEventArgs args = e as CSVAnomaliesFileUploadEventArgs;
                    if (args.Info == PropertyChangedEventArgs.InfoVal.FileUpdated)
                    {
                        notifyPropertyChanged(this, args);
                    }
                }
                if (e as XMLFileUploadEventArgs != null)
                {
                    XMLFileUploadEventArgs args = e as XMLFileUploadEventArgs;
                    if (args.Info == PropertyChangedEventArgs.InfoVal.FileUpdated)
                    {
                        notifyPropertyChanged(this, args);
                    }
                }
                // more....
            };

            learnedData    = new Dictionary <string, List <float> >();
            CategoriesMenu = new List <MenuItem>();
        }
示例#7
0
        public SettingsViewModel(ISettingsProvider settingsProvider, IMainModel mainModel)
        {
            _mainViewModel    = mainModel as MainViewModel;
            _settingsProvider = settingsProvider;

            TiApiKey    = Settings.TiApiKey;
            TgBotApiKey = Settings.TgBotApiKey;
            TgChatId    = Settings.TgChatId;
            TgChatIdRu  = Settings.TgChatIdRu;
            MinDayPriceChangePercent                  = Settings.MinDayPriceChange * 100m;
            MinXMinutesPriceChangePercent             = Settings.MinXMinutesPriceChange * 100m;
            MinVolumeDeviationFromDailyAveragePercent = Settings.MinVolumeDeviationFromDailyAverage * 100m;
            MinXMinutesVolPercentChangePercent        = Settings.MinXMinutesVolChange * 100m;
            NumOfMinToCheck           = Settings.NumOfMinToCheck;
            NumOfMinToCheckVol        = Settings.NumOfMinToCheckVol;
            IsTelegramEnabled         = Settings.IsTelegramEnabled;
            USAQuotesEnabled          = Settings.USAQuotesEnabled;
            USAQuotesURL              = Settings.USAQuotesURL;
            USAQuotesLogin            = Settings.USAQuotesLogin;
            USAQuotesPassword         = Settings.USAQuotesPassword;
            TgArbitrageLongUSAChatId  = Settings.TgArbitrageLongUSAChatId;
            TgArbitrageShortUSAChatId = Settings.TgArbitrageShortUSAChatId;
            SubscribeInstrumentStatus = Settings.SubscribeInstrumentStatus;
            HideRussianStocks         = Settings.HideRussianStocks;
            ChartUrlTemplate          = Settings.ChartUrlTemplate;
            ResetKeys();
        }
示例#8
0
 public MoveCoWireObjectService(
     IMainModel model,
     IParseAndAddFloatValue parseAndAddFloatValue)
 {
     _model = model ?? throw new System.ArgumentNullException(nameof(model));
     _parseAndAddFloatValue = parseAndAddFloatValue ?? throw new System.ArgumentNullException(nameof(parseAndAddFloatValue));
 }
示例#9
0
 public MainView(IMainModel model)
 {
     mainModel      = model as MainViewModel ?? throw new ArgumentException(nameof(model));
     menu           = new Menu <Action>(model);
     menuList       = new MenuList(menu.MenuActionsNames, columns: 3);
     menuValueRange = new InclusiveValueRange <int>(menu.MenuActionsNames.Length, 1);
 }
示例#10
0
        public MainPresenter(IMainView view, Controller controller, IFillView <File> fileView, IFillView <Resource> resourceView, IMainModel model)
        {
            _view         = view;
            _controller   = controller;
            _model        = model;
            _fileView     = fileView;
            _resourceView = resourceView;


            _view.WhileAnalysis  += WhileAnalysis;
            _view.ForAnalysis    += ForAnalysis;
            _view.DivCalculation += DivCalculate;
            _view.XorCalculation += XorCalculate;
            _view.AddFile        += AddFile;
            _view.AddResource    += AddRes;
            _view.UpdateFile     += UpdateFile;
            _view.UpdateResource += UpdateResourses;

            _view.DeleteFile     += DeleteFile;
            _view.DeleteResource += DeleteRes;
            _view.ExportFiles    += ExportFiles;
            _view.ImportFiles    += ImportFiles;
            _view.ExportRes      += ExportResources;
            _view.ImportRes      += ImportResources;

            _view.UpdateFiles(_model.Files);
            _view.UpdateResources(_model.Resources);
        }
        public void For_PatternDoesMatch_ReturnsInputStringWithNewCoordinates(
            [Frozen] IMainModel model,
            [Frozen] IParseAndAddFloatValue parseAndAddFloatValue,
            MoveCoWireObjectService sut)
        {
            //Arrange
            model.MoveXAxisValue.Returns(1);
            model.MoveYAxisValue.Returns(2);
            model.MoveZAxisValue.Returns(3);

            var input          = "14,co_wire,1,12.68545_2.453807_61.43925,3.329947_138.1346_1.069022E-07,-1,0.5,0,0,0,-1,12.68545_2.453807_61.43925&13.11526_2.416335_60.95963&0.5&2,-1,kcc0:h0:s0:v26:lr50:hr20,0,,%14,";
            var expectedResult = "14,co_wire,1,X_Y_Z,3.329947_138.1346_1.069022E-07,-1,0.5,0,0,0,-1,X_Y_Z&A_B_C&0.5&2,-1,kcc0:h0:s0:v26:lr50:hr20,0,,%14,";


            parseAndAddFloatValue.For("12.68545", 1).Returns("X");
            parseAndAddFloatValue.For("2.453807", 2).Returns("Y");
            parseAndAddFloatValue.For("61.43925", 3).Returns("Z");

            parseAndAddFloatValue.For("13.11526", 1).Returns("A");
            parseAndAddFloatValue.For("2.416335", 2).Returns("B");
            parseAndAddFloatValue.For("60.95963", 3).Returns("C");

            //Act
            var result = sut.For(input);

            //Assert
            result.Should().Be(expectedResult);
        }
        public void Reformat_ServiceFindsNoQuickMods_EliminatesAllLineBreaks(
            IMainModel mainModel,
            ReformatService sut,
            int randomLineBreakInserter
            )
        {
            //Arrange
            var lorizzleIppsle = "Lorizzle ipsum dolor ghetto amizzle, mah nizzle adipiscing elit. You son of a bizzle ut dolizzle.Things magna ligula, dignissim sit amizzle, that's the shizzle eget, the bizzle nec, the bizzle.";
            var content        = lorizzleIppsle;

            mainModel.FileContent.Returns(content);
            randomLineBreakInserter = randomLineBreakInserter % 5 + 2;

            mainModel.FileContent = lorizzleIppsle;
            var lineBreakCounter = 0;

            for (var i = randomLineBreakInserter; i < mainModel.FileContent.Length; i = i + randomLineBreakInserter + 1)
            {
                mainModel.FileContent.Insert(i, Environment.NewLine);
                lineBreakCounter++;
            }

            //Act
            sut.Reformat();

            //Assert
            mainModel.FileContent.Should().Be(lorizzleIppsle);
            lineBreakCounter.Should().NotBe(0);
        }
        public void WriteBackupFile_WritesBackupFile_EveryoneIsHappy(
            [Frozen] IMainModel model,
            string fileContent)
        {
            var directory     = @"C:\Temp\";
            var fileName      = "temp";
            var fileExtension = ".txt";
            var filePath      = directory + fileName + fileExtension;

            var mockedFileSystem  = new MockFileSystem();
            var mockedFileContent = new MockFileData(fileContent);

            mockedFileSystem.AddDirectory(directory);
            mockedFileSystem.AddFile(filePath, mockedFileContent);

            model.FileName = filePath;

            var sut = new BackupService(model, mockedFileSystem);

            sut.WriteBackupFile();

            var expectedPath = $"{directory}{fileName}_backup_{DateTime.Now:yyyyMMddHHmmss}{fileExtension}";

            mockedFileSystem.FileExists(expectedPath).Should().BeTrue();
        }
示例#14
0
 protected GraphCreatingModel(ILog log, IMainModel model, IAssembleClasses graphFactories)
 {
     GraphAssembleKeys    = graphFactories.ClassesNames.ToList();
     this.model           = model;
     graphAssembleClasses = graphFactories;
     this.log             = log;
 }
示例#15
0
        public MainController(IMainView view, IMainModel model)
        {
            _view = view;
            _model = model;

            InitializeViewEvents();
        }
示例#16
0
        public MainViewModel(IMainModel mainModel, ISettingsViewModel settingsViewModel,
                             IDownloadsViewModel downloadsViewModel,
                             ILogger logger)
        {
            if (mainModel == null)
            {
                throw new ArgumentNullException("mainModel");
            }
            if (settingsViewModel == null)
            {
                throw new ArgumentNullException("settingsViewModel");
            }
            if (downloadsViewModel == null)
            {
                throw new ArgumentNullException("downloadsViewModel");
            }
            if (logger == null)
            {
                throw new ArgumentNullException("logger");
            }

            this.mainModel          = mainModel;
            this.settingsViewModel  = settingsViewModel;
            this.downloadsViewModel = downloadsViewModel;
            this.logger             = logger;
        }
        public void Move_RegExMatchDoesNotContainPercentChar_ReplacesOneLine(
            [Frozen] IMainModel model,
            [Frozen] IFindWaggonsRegExService findWaggonsRegExService,
            [Frozen] IParseAndAddFloatValue parseAndAddFloatValue,
            MoveWaggonsService sut,
            string dummyContent,
            RegexServiceResponseModel regexServiceResponseModel,
            string dummyRegex)
        {
            //Arrange
            var source         = "ct_dynamic,1,16.73281_1.918186_60.32922,0_125.4218_0,43,36,42,0,0,0,0,0,0,0,0,0,0,0,-1,0,,1_0_-2_45_2.9_0_6_22_1_1_12,-1,0,4_0,kcc0:h0:s0:v49:lr50:hr20,,1,";
            var expectedResult = "ct_dynamic,1,X_Y_Z,0_125.4218_0,43,36,42,0,0,0,0,0,0,0,0,0,0,0,-1,0,,1_0_-2_45_2.9_0_6_22_1_1_12,-1,0,4_0,kcc0:h0:s0:v49:lr50:hr20,,1,";

            model.FileContent.Returns(dummyContent);
            regexServiceResponseModel.HasMatched    = true;
            regexServiceResponseModel.Content       = source;
            regexServiceResponseModel.MatchingRegEx = dummyRegex;
            findWaggonsRegExService.MatchRegex(dummyContent).Returns(regexServiceResponseModel);

            parseAndAddFloatValue.For("16.73281", Arg.Any <float>()).Returns("X");
            parseAndAddFloatValue.For("1.918186", Arg.Any <float>()).Returns("Y");
            parseAndAddFloatValue.For("60.32922", Arg.Any <float>()).Returns("Z");

            //Act
            sut.Move();

            //Assert
            model.ReceivedCalls().Should().HaveCount(6);
            findWaggonsRegExService.ReceivedCalls().Should().HaveCount(2);
            findWaggonsRegExService.Received(1).MatchRegex(dummyContent);
            findWaggonsRegExService.Received(1).Replace(dummyContent, expectedResult, regexServiceResponseModel.MatchingRegEx);
        }
 public GraphCreatingViewModel(ILog log, IMainModel model, IAssembleClasses graphFactories)
     : base(log, model, graphFactories)
 {
     ConfirmCreateGraphCommand = new RelayCommand(ExecuteConfirmCreateGraphCommand,
                                                  CanExecuteConfirmCreateGraphCommand);
     CancelCreateGraphCommand = new RelayCommand(ExecuteCloseWindowCommand);
 }
示例#19
0
 public PathFindingViewModel(ILog log, IAssembleClasses pluginsLoader,
                             IMainModel model, BaseEndPoints endPoints)
     : base(log, pluginsLoader, model, endPoints)
 {
     maxAlgorithmKeysNumber = pluginsLoader.ClassesNames.Count;
     minAlgorithmKeysNumber = 1;
 }
示例#20
0
        private void InstantiateModelsAndViews()
        {
            _startControl            = IoC.Resolve <IStartView>();
            _downloadModel           = IoC.Resolve <IDownloadModel>();
            _downloadView            = IoC.Resolve <IDownloadView>();
            _patchControl            = IoC.Resolve <IPatchView>();
            _patchModel              = IoC.Resolve <IPatchModel>();
            _dfuControl              = IoC.Resolve <IDfuView>();
            _dfuModel                = IoC.Resolve <IDfuModel>();
            _dfuSuccessControl       = IoC.Resolve <IDfuSuccessControl>();
            _tetherSuccessControl    = IoC.Resolve <ITetherSuccessControl>();
            _mainModel               = IoC.Resolve <IMainModel>();
            _firmwareVersionModel    = IoC.Resolve <IFirmwareVersionModel>();
            _tetherView              = IoC.Resolve <ITetherView>();
            _tetherModel             = IoC.Resolve <ITetherModel>();
            _firmwareVersionDetector = IoC.Resolve <IFirmwareVersionDetector>();
            _freeSpaceModel          = IoC.Resolve <IFreeSpaceModel>();

            _mainModel.SetFirmwareVersionModel(_firmwareVersionModel);
            _downloadModel.SetFirmwareVersionModel(_firmwareVersionModel);
            _patchModel.SetFirmwareVersionModel(_firmwareVersionModel);
            _dfuModel.SetFirmwareVersionModel(_firmwareVersionModel);
            _tetherModel.SetFirmwareVersionModel(_firmwareVersionModel);

            _tetherPresenter = new TetherPresenter(_tetherModel, _tetherView);
            _tetherPresenter.ProcessFinished += tetherPresenter_ProcessFinished;
            _patchPresetner                     = new PatchPresenter(_patchControl, _patchModel);
            _patchPresetner.Finished           += patchPresetner_Finished;
            _dfuPresenter                       = new DfuPresenter(_dfuModel, _dfuControl);
            _dfuPresenter.ProcessFinished      += dfuPresenter_ProcessFinished;
            _downloadPresenter                  = new DownloadPresenter(_downloadModel, _downloadView);
            _downloadPresenter.ProcessFinished += downloadPresenter_ProcessFinished;
        }
示例#21
0
        public TelegramManager(IServiceProvider serviceProvider, string apiToken, long chatId)
        {
            _apiToken        = apiToken;
            _services        = serviceProvider;
            _mainModel       = serviceProvider.GetRequiredService <IMainModel>();
            Settings         = serviceProvider.GetRequiredService <ISettingsProvider>().Settings;
            _logger          = (ILogger <TelegramManager>)serviceProvider.GetService(typeof(ILogger <TelegramManager>));
            _eventAggregator = (IEventAggregator2)serviceProvider.GetService(typeof(IEventAggregator2));
            try
            {
                _bot    = new TelegramBotClient(_apiToken);
                _chatId = chatId;

                _messageQueueLoopTask = Task.Factory
                                        .StartNew(() => BotMessageQueueLoopAsync()
                                                  .ConfigureAwait(false),
                                                  _cancellationTokenSource.Token,
                                                  TaskCreationOptions.LongRunning,
                                                  TaskScheduler.Default);
            }
            catch (Exception ex)
            {
                _logger.LogError("Telegram init error: {exception}", ex.Message);
            }
        }
示例#22
0
        public GraphModel(IMainModel mainModel)
        {
            this.mainModel      = mainModel;
            this.CurrCategoryPM = new PlotModel();
            CurrCategoryPM.Axes.Add(new LinearAxis
            {
                Title         = "Time",
                Minimum       = -5,
                Maximum       = 35,
                Position      = AxisPosition.Bottom,
                IsZoomEnabled = false
            });
            CurrCategoryPM.Axes.Add(new LinearAxis
            {
                Title         = "",
                Minimum       = 0,
                Maximum       = 0,
                Position      = AxisPosition.Left,
                IsZoomEnabled = false
            });

            this.CurrCorrelatedCategoryPM = new PlotModel();
            CurrCorrelatedCategoryPM.Axes.Add(new LinearAxis
            {
                Title         = "Time",
                Minimum       = -5,
                Maximum       = 35,
                Position      = AxisPosition.Bottom,
                IsZoomEnabled = false
            });
            CurrCorrelatedCategoryPM.Axes.Add(new LinearAxis
            {
                Title         = "",
                Minimum       = 0,
                Maximum       = 0,
                Position      = AxisPosition.Left,
                IsZoomEnabled = false
            });

            this.CorrelatedAsFuncOfCurrent = new PlotModel();
            CorrelatedAsFuncOfCurrent.Axes.Add(new LinearAxis
            {
                Title         = "",
                Minimum       = 0,
                Maximum       = 0,
                Position      = AxisPosition.Bottom,
                IsZoomEnabled = false
            });
            CorrelatedAsFuncOfCurrent.Axes.Add(new LinearAxis
            {
                Title         = "",
                Minimum       = 0,
                Maximum       = 0,
                Position      = AxisPosition.Left,
                IsZoomEnabled = false
            });

            AnomaliesData = new List <Anomaly>();
        }
示例#23
0
 public RocketMonitoringStrategy(ISettingsProvider settingsProvider, IMainModel mainModel, StocksManager stocksManager, IEventAggregator2 eventAggregator, ILogger <RocketMonitoringStrategy> logger)
 {
     StocksManager = stocksManager;
     Settings      = settingsProvider.Settings;
     MainModel     = mainModel;
     Logger        = logger;
     eventAggregator.SubscribeOnPublishedThread(this);
 }
 public DashboardViewModel(IMainModel model)
 {
     this.model             = model;
     model.PropertyChanged += delegate(Object sender, PropertyChangedEventArgs e)
     {
         NotifyPropertyChanged("VM_" + e.PropertyName);
     };
 }
        public FlightDisplayVM(IMainModel main, ISettingsModel settings)
        {
            MainModel     = main;
            SettingsModel = settings;

            // connect the server and client upon initialization
            ConnectCommand.Execute(null);
        }
示例#26
0
 public ProcessMonitorService ( IPerformanceCounterService performanceCounterService,
                                IPerformanceCounterInstanceInfoService performanceCounterInstanceInfoService,
                                IMainModel model )
 {
     _performanceCounterService = performanceCounterService;
     _performanceCounterInstanceInfoService = performanceCounterInstanceInfoService;
     _model = model;
 }
示例#27
0
 public MainView(IMainModel model)
 {
     mainModel       = model as MainViewModel;
     menuActions     = GetMenuMethodsAsDelegates <Action>(mainModel);
     menuActionsKeys = menuActions.Keys.ToArray();
     menu            = CreateMenu(menuActionsKeys, columns: 3);
     menuValueRange  = new ValueRange(menuActionsKeys.Length, 1);
 }
示例#28
0
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            view = new MainView();
            model = new MainModel();

            ctl = new MainController(view, model);

            ctl.Run();
        }
 public RemoveWaggonsService(
     IMainModel model,
     IReformatService reformatService,
     IRegExService regexService)
 {
     _model           = model ?? throw new ArgumentNullException(nameof(model));
     _reformatService = reformatService ?? throw new ArgumentNullException(nameof(reformatService));
     _regexService    = regexService ?? throw new ArgumentNullException(nameof(regexService));
 }
        /// <summary>
        ///     Presenter of main form
        /// </summary>
        /// <param name="serviceDesktopMainForm">Instance of interface main form</param>
        /// <param name="serviceDesktopModel">Instance of interface model</param>
        /// <param name="messageBoxService">Instance of interface message services</param>
        public MainPresenter(IMainView serviceDesktopMainForm,
                             IMainModel serviceDesktopModel, IMessageBoxService messageBoxService)
        {
            ServiceDesktopMainForm = serviceDesktopMainForm;
            ServiceDesktopModel    = serviceDesktopModel;
            MessageBoxService      = messageBoxService;

            SubscribeEvents();
        }
 public MoveTracksService(
     IMainModel mainModel,
     IFindTracksRegExService findTracksRegExService,
     IParseAndAddFloatValue parseAndAddFloatValue)
 {
     _mainModel = mainModel ?? throw new ArgumentNullException(nameof(mainModel));
     _findTracksRegExService = findTracksRegExService ?? throw new ArgumentNullException(nameof(findTracksRegExService));
     _parseAndAddFloatValue  = parseAndAddFloatValue ?? throw new ArgumentNullException(nameof(parseAndAddFloatValue));
 }
        public MainViewModel(IMainModel mainModel, INavigationService navigationService)
        {
            _mainModel         = mainModel;
            _navigationService = navigationService;

            SolveEquationCommand = new RelayCommand(OnSolveEquationCommand);

            ShowAboutCommand = new RelayCommand(OnShowAboutCommand);
        }
示例#33
0
 public override void TearDown()
 {
     m_Provider     = null;
     m_MainModel    = null;
     m_ChangesModel = null;
     m_View         = null;
     m_Presenter    = null;
     m_Window.rootVisualElement.Clear();
 }
示例#34
0
        public NewFolderViewModel(IMainModel mainModel, INavigationService navigationService, IGoogleDriveService googleDriveService, ISystemTrayService systemTrayService, IMessageBoxService messageBoxService)
        {
            _mainModel = mainModel;
            _navigationService = navigationService;
            _googleDriveService = googleDriveService;
            _systemTrayService = systemTrayService;
            _messageBoxService = messageBoxService;

            CreateNewFolderCommand = new RelayCommand(CreateNewFolder, () => !IsBusy);
        }
示例#35
0
        public RenameFileViewModel(IMainModel mainModel, INavigationService navigationService, IGoogleDriveService googleDriveService, ISystemTrayService systemTrayService, IMessageBoxService messageBoxService)
        {
            _mainModel = mainModel;
            _navigationService = navigationService;
            _googleDriveService = googleDriveService;
            _systemTrayService = systemTrayService;
            _messageBoxService = messageBoxService;

            RenameFileCommand = new RelayCommand(RenameFile, () => !IsBusy);

            PageLoadedCommand = new RelayCommand(() =>
            {
                FileName = _mainModel.SelectedFile.Title;
            });
        }
示例#36
0
        public AuthorizationViewModel(IMainModel mainModel, IGoogleAuthService googleAuthService, IGoogleOAuth2Service googleOAuth2Service, INavigationService navigationService, IMessageBoxService messageBoxService, ISystemTrayService systemTrayService)
        {
            _mainModel = mainModel;
            _googleAuthService = googleAuthService;
            _googleOAuth2Service = googleOAuth2Service;
            _navigationService = navigationService;
            _messageBoxService = messageBoxService;
            _systemTrayService = systemTrayService;

            PageLoadedCommand = new RelayCommand(() =>
            {
                ShowBrowser = true;

                WebBrowserSourceUri = _googleAuthService.GetAuthUri();
            });

            WebBrowserNavigatingCommand = new RelayCommand<NavigatingEventArgs>(e =>
            {
                if (_showBrowser)
                {
                    _systemTrayService.SetProgressIndicator("");
                }

                if (e.Uri == null || e.Uri.Host != "localhost")
                    return;

                ShowBrowser = false;

                WebBrowserSourceUri = new Uri("https://accounts.google.com/Logout");

                var queryString = e.Uri.QueryString();

                ExchangeAuthorizationCode(queryString.GetValue("code"));
            });

            WebBrowserNavigatedCommand = new RelayCommand<NavigationEventArgs>(e =>
            {
                if (_showBrowser)
                {
                    _systemTrayService.HideProgressIndicator();
                }
            });

            WebBrowserNavigationFailedCommand = new RelayCommand<NavigationFailedEventArgs>(e =>
            {
                _systemTrayService.HideProgressIndicator();
            });
        }
示例#37
0
        public MainViewModel(IMainModel mainModel, ISettingsViewModel settingsViewModel,
            IDownloadsViewModel downloadsViewModel,
            ILogger logger)
        {
            if (mainModel == null)
                throw new ArgumentNullException("mainModel");
            if (settingsViewModel == null)
                throw new ArgumentNullException("settingsViewModel");
            if (downloadsViewModel == null)
                throw new ArgumentNullException("downloadsViewModel");
            if (logger == null)
                throw new ArgumentNullException("logger");

            this.mainModel = mainModel;
            this.settingsViewModel = settingsViewModel;
            this.downloadsViewModel = downloadsViewModel;
            this.logger = logger;
        }
        private void InstantiateModelsAndViews()
        {
            startControl = IoC.Resolve<IStartView>();
            syncContext = startControl.SyncContext;
            downloadModel = IoC.Resolve<IDownloadModel>();
            downloadView = IoC.Resolve<IDownloadView>();
            patchControl = IoC.Resolve<IPatchView>();
            patchModel = IoC.Resolve<IPatchModel>();
            dfuControl = IoC.Resolve<IDFUView>();
            dfuModel = IoC.Resolve<IDFUModel>();
            dfuSuccessControl = IoC.Resolve<IDFUSuccessControl>();
            tetherSuccessControl = IoC.Resolve<ITetherSuccessControl>();
            mainModel = IoC.Resolve<IMainModel>();
            firmwareVersionModel = IoC.Resolve<IFirmwareVersionModel>();
            tetherView = IoC.Resolve<ITetherView>();
            tetherModel = IoC.Resolve<ITetherModel>();
            firmwareVersionDetector = IoC.Resolve<IFirmwareVersionDetector>();
            freeSpaceModel = IoC.Resolve<IFreeSpaceModel>();
            iTunesInfoProvider = IoC.Resolve<IITunesInfoProvider>();

            iTunesAutomationModel = IoC.Resolve<IITunesAutomationModel>();
            iTunesAutomationModel.FirmwareVersionModel = firmwareVersionModel;
            iTunesAutomationModel.SyncContext = syncContext;
            iTunesAutomationModel.ITunesInfoProvider = iTunesInfoProvider;

            mainModel.SetFirmwareVersionModel(firmwareVersionModel);
            downloadModel.SetFirmwareVersionModel(firmwareVersionModel);
            patchModel.SetFirmwareVersionModel(firmwareVersionModel);
            dfuModel.SetFirmwareVersionModel(firmwareVersionModel);
            tetherModel.SetFirmwareVersionModel(firmwareVersionModel);

            tetherPresenter = new TetherPresenter(tetherModel, tetherView);
            tetherPresenter.ProcessFinished += tetherPresenter_ProcessFinished;
            patchPresetner = new PatchPresenter(patchControl, patchModel);
            patchPresetner.Finished += patchPresetner_Finished;
            dfuPresenter = new DFUPresenter(dfuModel, dfuControl);
            dfuPresenter.ProcessFinished += dfuPresenter_ProcessFinished;
            downloadPresenter = new DownloadPresenter(downloadModel, downloadView);
            downloadPresenter.ProcessFinished += downloadPresenter_ProcessFinished;
        }
示例#39
0
        public ViewFileViewModel(IMainModel mainModel, IGoogleDriveService googleDriveService, IMessageBoxService messageBoxService, ISystemTrayService systemTrayService, IMediaLibraryService mediaLibraryService)
        {
            _mainModel = mainModel;
            _googleDriveService = googleDriveService;
            _messageBoxService = messageBoxService;
            _systemTrayService = systemTrayService;
            _mediaLibraryService = mediaLibraryService;

            DownloadFileCommand = new RelayCommand(DownloadFile, () => !IsBusy && CanDownload);

            BackKeyPressCommand = new RelayCommand<CancelEventArgs>(e =>
            {
                AbortCurrentCall(false);
            });
        }
示例#40
0
		public MainPresenter(IMainView view, IMainModel model, SynchronizationContext context)
		{
			_model = model;
			_view = view;
			_context = context;
		}
示例#41
0
 public MainPresenter(IMainView _view, IMainModel _model)
 {
     view = _view;
     model = _model;
 }
示例#42
0
        public ExplorerViewModel(IMainModel mainModel, IGoogleDriveService googleDriveService, INavigationService navigationService, IMessageBoxService messageBoxService, ISystemTrayService systemTrayService, IPhotoChooserService photoChooserService)
        {
            _mainModel = mainModel;
            _googleDriveService = googleDriveService;
            _navigationService = navigationService;
            _messageBoxService = messageBoxService;
            _systemTrayService = systemTrayService;
            _photoChooserService = photoChooserService;

            Files = new ObservableCollection<GoogleFileViewModel>();
            PictureFiles = new ObservableCollection<GoogleFileViewModel>();

            OpenFileCommand = new RelayCommand<GoogleFileViewModel>(file =>
            {
                if (IsSelectionEnabled)
                {
                    return;
                }

                OpenFile(file);
            });

            ChangeStaredStatusCommand = new RelayCommand<GoogleFileViewModel>(file =>
            {
                if (IsSelectionEnabled)
                {
                    return;
                }

                ChangeStaredStatus(file);
            });

            AddFileCommand = new RelayCommand(UploadFile);

            EnableSelectionCommand = new RelayCommand(() =>
            {
                if (IsBusy)
                {
                    return;
                }

                IsSelectionEnabled = true;
            });

            RefreshFilesCommand = new RelayCommand(RefreshFiles);

            DeleteFilesCommand = new RelayCommand<IList>(files =>
            {
                _messageBoxService.Show("You are about to delete the selected files. Do you wish to proceed?", "Delete files?", new[] { "delete", "cancel" }, button =>
                {
                    if (button != 0)
                        return;

                    var filesArray = files
                        .Cast<GoogleFileViewModel>()
                        .ToArray();

                    IsSelectionEnabled = false;

                    DeleteFiles(filesArray);
                });
            });

            CreateNewFolderCommand = new RelayCommand(CreateNewFolder);

            RenameFileCommand = new RelayCommand<GoogleFileViewModel>(RenameFile);

            DeleteFileCommand = new RelayCommand<GoogleFileViewModel>(file =>
            {
                _messageBoxService.Show(string.Format("You are about to delete '{0}'. Do you wish to proceed?", file.Title), "Delete file?", new[] { "delete", "cancel" }, button =>
                {
                    if (button != 0)
                        return;

                    DeleteFile(file);
                });
            });

            ShowAboutCommand = new RelayCommand(() =>
            {
                _navigationService.NavigateTo("/View/AboutPage.xaml");
            });

            PageLoadedCommand = new RelayCommand(ExecuteInitialLoad);

            BackKeyPressCommand = new RelayCommand<CancelEventArgs>(e =>
            {
                GoogleDriveFile item;

                if (PivotSelectedIndex == 1)
                {
                    PivotSelectedIndex = 0;

                    e.Cancel = true;
                }
                else if (IsSelectionEnabled)
                {
                    IsSelectionEnabled = false;

                    e.Cancel = true;
                }
                else if (_mainModel.TryPop(out item))
                {
                    AbortCurrentCall();

                    RaisePropertyChanged(() => CurrentPath);

                    RefreshFiles();

                    e.Cancel = true;
                }
                else
                {
                    AbortCurrentCall(true);

                    Files.Clear();
                    PictureFiles.Clear();
                }
            });

            MessengerInstance.Register<RefreshFilesMessage>(this, message =>
            {
                DispatcherHelper.RunAsync(RefreshFiles);
            });
        }
示例#43
0
        public MainViewModel(IMainModel mainModel, INavigationService navigationService, IMessageBoxService messageBoxService, IApplicationSettingsService applicationSettingsService, IShellTileService shellTileService)
        {
            _mainModel = mainModel;
            _navigationService = navigationService;
            _messageBoxService = messageBoxService;
            _applicationSettingsService = applicationSettingsService;
            _shellTileService = shellTileService;

            NewAccountCommand = new RelayCommand(() =>
            {
                _navigationService.NavigateTo("/View/AuthorizationPage.xaml");
            });

            RemoveAccountCommand = new RelayCommand<AccountViewModel>(account =>
            {
                _mainModel.AvailableAccounts.Remove(account.Model);
                _mainModel.Save();

                RefreshAccountsList();
            });

            OpenAccountCommand = new RelayCommand<AccountViewModel>(account =>
            {
                _mainModel.CurrentAccount = account.Model;
                _mainModel.ExecuteInitialLoad = true;

                _navigationService.NavigateTo("/View/ExplorerPage.xaml");
            });

            ShowAboutCommand = new RelayCommand(() =>
            {
                _navigationService.NavigateTo("/View/AboutPage.xaml");
            });

            PageLoadedCommand = new RelayCommand(() =>
            {
                _mainModel.CurrentAccount = null;

                if (!_applicationSettingsService.Get<bool>("AcceptedDisclaimer", false))
                {
                    _applicationSettingsService.Set("AcceptedDisclaimer", true);
                    _applicationSettingsService.Save();

                    _messageBoxService.Show("You are advised to read the GDrive disclaimer before you continue.\n\nWould you like to read it now?\n\nYou can always find it later in the About page.", "Welcome to GDrive", new[] { "now", "later" }, buttonIndex =>
                    {
                        if (buttonIndex == 0)
                        {
                            _navigationService.NavigateTo("/View/AboutPage.xaml?disclaimer=true");
                        }
                    });
                }
            });

            MessengerInstance.Register<AvailableAccountsChangedMessage>(this, message =>
            {
                RefreshAccountsList();
            });

#if !WP8
            DispatcherHelper.RunAsync(UpdateTiles);
#endif
        }
示例#44
0
 public GnuPlotGeneratorService ( IMainModel model )
 {
     _model = model;
 }
示例#45
0
 /// <summary>
 /// Initialize the <c>Model</c>
 /// </summary>
 /// <remarks>
 ///     <para>Called by the <c>initializeFacade</c> method. Override this method in your subclass of <c>Facade</c> if one or both of the following are true:</para>
 ///     <list type="bullet">
 ///         <item>You wish to initialize a different <c>IModel</c></item>
 ///         <item>You have <c>Model</c>s to register with the Model that do not retrieve a reference to the Facade at construction time</item>
 ///     </list>
 ///     <para>If you don't want to initialize a different <c>IModel</c>, call <c>base.initializeModel()</c> at the beginning of your method, then register <c>Model</c>s</para>
 ///     <para>Note: This method is <i>rarely</i> overridden; in practice you are more likely to use a <c>Controller</c> to create and register <c>Model</c>s with the <c>Model</c>, since <c>Model</c>s with mutable data will likely need to send <c>INotification</c>s and thus will likely want to fetch a reference to the <c>Facade</c> during their construction</para>
 /// </remarks>
 protected virtual void InitializeMainModel()
 {
     if (this.mMainModel != null) return;
     this.mMainModel = MainModel.Instance;
 }
 public MainPresenter(IMainModel model, IMainView view)
     : base(model, view) {
 }
示例#47
0
 public LogService(IMainModel model)
 {
     _model = model;
 }
示例#48
0
 public MainPresenter(IMainView mainView)
 {
     this.mainView = mainView;
     this.mainModel = new MainModel();
 }