protected async void OnOkCommand()
        {
            try
            {
                await _SemaphoreSlimOnOkCommand.WaitAsync();

                UpdateOptionSettings();
                _loggerService?.LogEvent(nameof(OnOkCommand));
                ImageAction Action      = OverwriteFiles ? ImageAction.Save : ImageAction.SaveAs;
                bool        successfull = await ResizeImages(Action);

                if (successfull && _localSettings.Settings.ClearImageListAfterSuccess && ImageFiles?.Count != 0)
                {
                    CancelCommand?.Execute(ImageFiles);
                }
                //if the app was started from command line exit the app after resize
                if (AppStartType.CommandLine.Equals(_appStartType))
                {
                    _applicationService.Exit();
                }
            }
            catch (Exception e)
            {
                _loggerService?.LogException(nameof(OnOkCommand), e);
            }
            finally
            {
                _SemaphoreSlimOnOkCommand.Release();
            }
        }
        /// <summary>
        /// Initialization of the package; this method is called right after the package is sited, so this is the place
        /// where you can put all the initialization code that rely on services provided by VisualStudio.
        /// </summary>
        protected override void Initialize()
        {
            IProjectInfoProvider solutionInfoProvider = new SolutionInfoProvider(this);
            IProjectInfoProvider projectInfoProvider  = new ProjectInfoProvider(this);
            IProjectInfoProvider fileInfoProvider     = new FileInfoProvider(this);

            IProjectInfoProvider solutionSnapshotInfoProvider = new SolutionInfoProvider(this, true);
            IProjectInfoProvider projectSnapshotInfoProvider  = new ProjectInfoProvider(this, true);

            IDexterInfoProvider dexterInfoProvider = new SettingsStoreDexterInfoProvider(this);

            ConfigurationProvider solutionConfigProvider = new ConfigurationProvider(solutionInfoProvider, dexterInfoProvider);
            ConfigurationProvider projectConfigProvider  = new ConfigurationProvider(projectInfoProvider, dexterInfoProvider);
            ConfigurationProvider fileConfigProvider     = new ConfigurationProvider(fileInfoProvider, dexterInfoProvider);

            ConfigurationProvider solutionSnapshotConfigProvider = new ConfigurationProvider(solutionSnapshotInfoProvider, dexterInfoProvider);
            ConfigurationProvider projectSnapshotConfigProvider  = new ConfigurationProvider(projectSnapshotInfoProvider, dexterInfoProvider);

            var commandSet = new Guid("2ed6d891-bce1-414d-8251-80a0800a831f");

            DexterAnalysisCommand fileAnalysisCommand     = new DexterFileAnalysisCommand(this, 0x0102, commandSet, fileConfigProvider);
            DexterAnalysisCommand projectAnalysisCommand  = new DexterSolutionAnalysisCommand(this, 0x0101, commandSet, projectConfigProvider);
            DexterAnalysisCommand solutionAnalysisCommand = new DexterSolutionAnalysisCommand(this, 0x0100, commandSet, solutionConfigProvider);
            DexterAnalysisCommand projectSnapshotCommand  = new DexterSolutionAnalysisCommand(this, 0x0111, commandSet, projectSnapshotConfigProvider);
            DexterAnalysisCommand solutionSnapshotCommand = new DexterSolutionAnalysisCommand(this, 0x0110, commandSet, solutionSnapshotConfigProvider);

            settingsCommand  = new SettingsCommand(this, 0x0103, commandSet);
            dashboardCommand = new DashboardCommand(this, 0x0104, commandSet, dexterInfoProvider);
            cancelCommand    = new CancelCommand(this, 0x0105, commandSet);

            DexterAnalysisCommand solutionAnalysisToolbarCommand = new DexterSolutionAnalysisCommand(this, 0x0200, commandSet, solutionConfigProvider);

            settingsToolbarCommand  = new SettingsCommand(this, 0x0203, commandSet);
            dashboardToolbarCommand = new DashboardCommand(this, 0x0204, commandSet, dexterInfoProvider);
            cancelToolbarCommand    = new CancelCommand(this, 0x0205, commandSet);

            analysisCommands.Add(fileAnalysisCommand);
            analysisCommands.Add(projectAnalysisCommand);
            analysisCommands.Add(solutionAnalysisCommand);
            analysisCommands.Add(projectSnapshotCommand);
            analysisCommands.Add(solutionSnapshotCommand);
            analysisCommands.Add(solutionAnalysisToolbarCommand);

            foreach (DexterAnalysisCommand analysisCommand in analysisCommands)
            {
                analysisCommand.AnalysisStarted  += onAnalysisStarted;
                analysisCommand.AnalysisFinished += onAnalysisFinished;
            }

            SettingsPage settingsPage = (SettingsPage)GetDialogPage(typeof(SettingsPage));

            settingsPage.SettingsChanged += onSettingsChanged;

            PeerReviewService.Instance = new PeerReviewService(new DexterTextService());

            RegisterSolutionManager();
            CreateReviewCommentManager();

            base.Initialize();
        }
Пример #3
0
 protected override void OnPropertyChanged(string propertyName)
 {
     base.OnPropertyChanged(propertyName);
     if (propertyName == "CanSave")
     {
         SaveCommand.RaiseCanExecuteChanged();
     }
     else if (propertyName == "CanCancel")
     {
         CancelCommand.RaiseCanExecuteChanged();
     }
     else if (propertyName == "CanDelete")
     {
         DeleteCommand.RaiseCanExecuteChanged();
     }
     else if (propertyName == "CanRemove")
     {
         RemoveCommand.RaiseCanExecuteChanged();
     }
     else if (propertyName == "CanAddNew")
     {
         AddCommand.RaiseCanExecuteChanged();
     }
     else if (propertyName == "IsBusy")
     {
         RefreshCommands();
     }
 }
        private async void DoLogin()
        {
            if (string.IsNullOrWhiteSpace(Login) || string.IsNullOrWhiteSpace(Password))
            {
                return;
            }

            IsWorking = true;
            CanLogin  = false;

            try
            {
                await AccountManager.LoginLastFm(Login, Password);

                CancelCommand.Execute(null);
            }
            catch (LastFmLoginException ex)
            {
                LoggingService.Log(ex.ToString());

                LoginError = ErrorResources.LoginErrorInvalidClient;
                CanLogin   = true;
                IsWorking  = false;
            }
            catch (Exception ex)
            {
                LoggingService.Log(ex.ToString());

                CanLogin  = true;
                IsWorking = false;
            }
        }
Пример #5
0
 private void Cancel()
 {
     if (CancelCommand != null)
     {
         CancelCommand.Execute(new object());
     }
 }
        public EggProductionEntryViewModel(IMessageBroker broker, IEggProductionService service, IConsumableUsageService usageService,
                                           IHenHouseService houseService, SaveEggProductionCommand saveCommand, CancelCommand cancelCommand,
                                           ShowEggProductionListCommand showListCommand)
        {
            this.broker       = broker;
            this.service      = service;
            this.usageService = usageService;
            ActualSaveCommand = saveCommand;

            CancelCommand   = cancelCommand;
            ShowListCommand = showListCommand;

            PropertiesToValidate = new List <string> {
                "Date", "Details"
            };

            InitializeCommands();
            NavigationCommands = new List <CommandBase>()
            {
                SaveCommand, CancelCommand, RefreshCommand
            };
            CancelCommand.Action = b => showListCommand.Execute(null);

            HenHouses = new ObservableCollection <HenHouse>(houseService.GetAll().OrderBy(h => h.Name));

            SubscribeMessages();
        }
Пример #7
0
        private void SetEventHandlers()
        {
            MainList.CollectionChanged += UpdateStatusTexts;

            _remotes.Loading += (s, e) =>
            {
                BusyText        = "Getting list of files ...";
                RetryingText    = "";
                MessageTone     = L4j.Info;
                IsDelayingRetry = false;
            };

            _remotes.DelayingRetry += (s, e) =>
            {
                BusyText        = $"Unable to get list of files.";
                RetryingText    = $"retrying in {e.Value} ...";
                MessageTone     = L4j.Warn;
                IsDelayingRetry = true;
            };

            PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == nameof(IsBusy) ||
                    e.PropertyName == nameof(IsDelayingRetry))
                {
                    CancelCommand.Fire_CanExecuteChanged();
                }
            };

            Cancelled += (s, e)
                         => { _remotes.RaiseCancelled(); };
        }
Пример #8
0
        public DownloadingViewModel(IUnityContainer container) : base(container)
        {
            PauseAllCommand = new RelayCommand(() =>
            {
                foreach (var task in TransferTasks)
                {
                    if (PauseCommand.CanExecute(task))
                    {
                        PauseCommand.Execute(task);
                    }
                }
            },
                                               () => TransferTasks?.Any() ?? false);

            CancelAllCommand = new RelayCommand(() =>
            {
                foreach (var task in TransferTasks)
                {
                    if (CancelCommand.CanExecute(task))
                    {
                        CancelCommand.Execute(task);
                    }
                }
            },
                                                () => TransferTasks?.Any() ?? false);
        }
        public void AddToCart()
        {
            if (_navigationService.HostScreen.CurrentUser != null)
            {
                if (CurrentUserCard != null && CurrentUserCard.Activated != false)
                {
                    ILoansService _loans = IoC.ServiceProvider.GetService <ILoansService>();

                    _loans.LoanCart.Add(currentBook);
                    _dialog.Alert("Varukorg", $"Tillagd i varukorgen");
                    if (currentBook.Category == 1)
                    {
                        currentBook.Quantity--;
                    }

                    CancelCommand.Execute(null);
                }
                else
                {
                    _dialog.Alert("Lånekort", "Du har inget Lånekort registrerat eller aktiverat \nVänligen kontakta personalen");
                }
            }
            else
            {
                _dialog.Alert("Login", "Vänligen logga in för att låna");
            }
        }
Пример #10
0
 public AccountCreationPageViewModel()
 {
     User                  = new User();
     CancelCommand         = new CancelCommand();
     GenerateNumberCommand = new GenerateNumberCommand(this);
     CreateCommand         = new CreateCommand(this);
 }
Пример #11
0
 void RaisePostBackEvent(string eventArgument)
 {
     if (eventArgument == "Upload")
     {
         HttpPostedFile uploadedFile = Page.Request.Files[ClientID + "_Upload"];
         if (uploadedFile != null && uploadedFile.ContentLength > 0)
         {
             FileManagerItemInfo dir = GetCurrentDirectory();
             Controller.ProcessFileUpload(dir, uploadedFile);
         }
     }
     else if (eventArgument == "Select")
     {
         if (SelectCommand != null)
             SelectCommand.Invoke(this, EventArgs.Empty);
     }
     else if (eventArgument == "Cancel")
     {
         if (CancelCommand != null)
             CancelCommand.Invoke(this, EventArgs.Empty);
     }
     else if (eventArgument.StartsWith("Toolbar:", StringComparison.Ordinal))
     {
         int i = int.Parse(eventArgument.Substring(8));
         CustomToolbarButton button = CustomToolbarButtons[i];
         OnToolbarCommand(new CommandEventArgs(button.CommandName, button.CommandArgument));
     }
 }
Пример #12
0
        public SolveAddView()
        {
            InitializeComponent();
            SolveTextBox            = this.FindControl <TextBox>("SolveTextBox");
            SolveTextBox.Text       = "00:00:00.00";
            SolveTextBox.CaretIndex = 6;
            SolveTextBox.CaretBrush = Avalonia.Media.Brushes.Yellow;
            SolveTextBox.AddHandler(TextInputEvent, PreviewTextInput, RoutingStrategies.Tunnel);
            SolveTextBox.AddHandler(KeyDownEvent, PreviewKeyDown, RoutingStrategies.Tunnel);

            CancelButton = this.Find <Button>("CancelButton");
#if DEBUG
            this.AttachDevTools();
#endif

            this.WhenActivated(disposableRegistration =>
            {
                this.BindCommand(
                    ViewModel,
                    viewModel => viewModel.CancelCommand,
                    view => view.CancelButton)
                .DisposeWith(disposableRegistration);

                ViewModel !.CancelCommand.Subscribe(_ => Close())
                .DisposeWith(disposableRegistration);
            });
        }
Пример #13
0
 private void maininput_PreviewKeyDown(object sender, KeyEventArgs e)
 {
     try
     {
         if (e.Key == Key.Escape)
         {
             if (string.IsNullOrEmpty(maininput.Text))
             {
                 if (CancelCommand != null)
                 {
                     CancelCommand.Execute(null);
                 }
             }
             else
             {
                 SearchText = "";
                 e.Handled  = true;
             }
         }
         if (e.Key == Key.Enter)
         {
             if (AcceptCommand != null)
             {
                 AcceptCommand.Execute(maininput.Text);
             }
         }
     }
     catch (Exception ex)
     {
         logger.Error(ex);
     }
 }
 private void SaveAction(object obj)
 {
     try
     {
         if (this.context.Save(Selected))
         {
             if (Message.QuestionYesNo("Data Berhasil Disimpan, Print Faktur ?"))
             {
                 Selected.NamaCustomer = Selected.Customer.NamaCustomer;
                 Selected.KodeCustomer = Selected.Customer.KodeCustomer;
                 var layout = "MainApp.Reports.Layouts.FakturPernjualan.rdlc";
                 if (Selected.Pembayaran == StatusPembayaran.Kredit)
                 {
                     layout = "MainApp.Reports.Layouts.FakturPernjualanKredit.rdlc";
                 }
                 HelperPrint.PrintWithFormActionTwoSource("Print Preview",
                                                          new ReportDataSource {
                     Name = "Header", Value = new List <Penjualan> {
                         Selected
                     }
                 },
                                                          new ReportDataSource {
                     Name = "DataSet1", Value = Selected.Details.ToList()
                 },
                                                          layout, null);
             }
             BarangSourceView.Refresh();
             CancelCommand.Execute(null);
         }
     }
     catch (Exception ex)
     {
         Message.Error(ex.Message);
     }
 }
Пример #15
0
        private void OnToolbarClick(object sender, ToolbarButtonClickEventArgs e)
        {
            switch (e.ClickedButton)
            {
            case ToolbarButton.Back:
                BackCommand?.TryExecute();
                break;

            case ToolbarButton.Edit:
                EditCommand?.TryExecute();
                break;

            case ToolbarButton.Delete:
                DeleteCommand?.TryExecute();
                break;

            case ToolbarButton.Save:
                SaveCommand?.TryExecute();
                break;

            case ToolbarButton.Cancel:
                CancelCommand?.TryExecute();
                break;
            }
        }
        public IObservable <RecoveryOptionResult> Show(UserError userError)
        {
            IsBusy = false;
            var error = userError as TwoFactorRequiredUserError;

            Debug.Assert(error != null,
                         String.Format(CultureInfo.InvariantCulture, "The user error is '{0}' not a TwoFactorRequiredUserError", userError));
            InvalidAuthenticationCode = error.RetryFailed;
            TwoFactorType             = error.TwoFactorType;
            var ok = OkCommand
                     .Do(_ => IsBusy = true)
                     .Select(_ => AuthenticationCode == null
                    ? RecoveryOptionResult.CancelOperation
                    : RecoveryOptionResult.RetryOperation)
                     .Do(_ => error.ChallengeResult = AuthenticationCode != null
                    ? new TwoFactorChallengeResult(AuthenticationCode)
                    : null);
            var resend = ResendCodeCommand.Select(_ => RecoveryOptionResult.RetryOperation)
                         .Do(_ => error.ChallengeResult = TwoFactorChallengeResult.RequestResendCode);
            var cancel = CancelCommand.Select(_ => RecoveryOptionResult.CancelOperation);

            return(Observable.Merge(ok, cancel, resend)
                   .Take(1)
                   .Do(_ => IsAuthenticationCodeSent = error.ChallengeResult == TwoFactorChallengeResult.RequestResendCode));
        }
        public UsageEntryViewModel(IMessageBroker messageBroker, IConsumableUsageService usageService,
                                   IHenHouseService houseService, IConsumableService consumableService,
                                   SaveUsageCommand saveUsageCommand, CancelCommand cancelCommand, ShowUsageCommand showListCommand
                                   )
        {
            this.messageBroker     = messageBroker;
            this.usageService      = usageService;
            this.houseService      = houseService;
            this.consumableService = consumableService;

            this.saveUsageCommand = saveUsageCommand;
            this.showListCommand  = showListCommand;

            CancelCommand = cancelCommand;

            PropertiesToValidate = new List <string>()
            {
                "Date",
                "Total",
                "Details"
            };

            InitializeCommands();

            HouseList      = new ObservableCollection <HenHouse>(houseService.GetAll());
            ConsumableList = new ObservableCollection <Consumable>(consumableService.GetAll());

            SubscribeMessages();
        }
Пример #18
0
        private async Task LoadChromecasts()
        {
            try
            {
                LoadingChromecasts = true;
                var ip = LocalIPAddress().ToString();
                var foundChromecasts = await _chromecastService.StartLocatingDevices(ip);

                foreach (var foundChromecast in foundChromecasts)
                {
                    Chromecasts.Add(foundChromecast);
                }

                LoadingChromecasts = false;
                AnyChromecast      = Chromecasts.Any();
            }
            catch (Exception ex)
            {
                LoadingChromecasts = false;
                AnyChromecast      = false;
                Logger.Error(ex);
                Messenger.Default.Send(
                    new UnhandledExceptionMessage(
                        new PopcornException(LocalizationProviderHelper.GetLocalizedValue <string>("CastFailed"))));
                CancelCommand.Execute(null);
                CloseCommand.Execute(null);
            }
        }
 private void InvalidateCommands()
 {
     SaveCommand.RaiseCanExecuteChanged();
     CancelCommand.RaiseCanExecuteChanged();
     RoleChangedCommand.RaiseCanExecuteChanged();
     GenPersonCodeCommand.RaiseCanExecuteChanged();
 }
 private void ItemPropertyChanged(object sender, PropertyChangedEventArgs e)
 {
     _changeProvided = true;
     Trace.WriteLine("Value of property has changed");
     SaveCommand.RaiseCanExecuteChanged();
     CancelCommand.RaiseCanExecuteChanged();
 }
Пример #21
0
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            if (e.OriginalSource is Button button)
            {
                switch (button.Name)
                {
                case "buttonEdit":
                    EditCommand?.Execute(null);
                    break;

                case "buttonDelete":
                    DeleteCommand?.Execute(null);
                    break;

                case "buttonCancel":
                    CancelCommand?.Execute(null);
                    break;

                case "buttonSave":
                    SaveCommand?.Execute(null);
                    break;

                case "buttonAdd":
                    AddCommand?.Execute(null);
                    break;
                }
            }
        }
Пример #22
0
        public async Task SupportsCooperativeCancellation()
        {
            using (CancellationTokenSource cts = new())
            {
                CommandBase command = new CancellationCommand();
                cts.Cancel();

                OperationCanceledException exception = await Assert.ThrowsAsync <OperationCanceledException>(() => command.ExecuteAsync(cts.Token));

                Assert.Equal(cts.Token, exception.CancellationToken);
            }

            using (CancellationTokenSource cts = new())
            {
                CommandBase command = new CancelCommand();
                cts.Cancel();

                Task <CommandResult> task = command.ExecuteAsync(cts.Token);

                TaskCanceledException exception = await Assert.ThrowsAsync <TaskCanceledException>(() => task);

                Assert.Equal(cts.Token, exception.CancellationToken);
                Assert.Same(task, exception.Task);

                Assert.Equal(TaskStatus.Canceled, task.Status);
                Assert.Null(task.Exception);
            }
        }
        public EmployeeCostEntryViewModel(
            IMessageBroker messageBroker,
            IEmployeeCostService costService,
            IEmployeeService employeeService,
            SaveEmployeeCostCommand saveCostCommand,
            CancelCommand cancelCommand, ShowEmployeeCostCommand showListCommand
            )
        {
            this.messageBroker   = messageBroker;
            this.costService     = costService;
            this.employeeService = employeeService;
            ActualSaveCommand    = saveCostCommand;

            CancelCommand       = cancelCommand;
            ShowCostListCommand = showListCommand;
            InitializeCommands();
            NavigationCommands = new List <CommandBase> {
                SaveCommand, CancelCommand
            };
            CancelCommand.Action = broker => showListCommand.Execute(null);

            PropertiesToValidate = new List <string>()
            {
                "Date",
                "Total",
                "Details"
            };

            Employees = new ObservableCollection <Employee>(employeeService.GetAll());

            SubscribeMessages();
        }
Пример #24
0
 /// <summary>
 /// Requests cancellation of the command.
 /// </summary>
 public void Cancel()
 {
     if (CancelCommand.CanExecute())
     {
         CancelCommand.Execute();
     }
 }
        public MainWindowViewModel()
        {
            EdgeLocalStateFilePath.SetValidateNotifyError(IsExitisFile);
            EdgeCookiesFilePath.SetValidateNotifyError(IsExitisFile);
            ChromeLocalStateFilePath.SetValidateNotifyError(IsExitisFile);
            ChromeCookiesFilePath.SetValidateNotifyError(IsExitisFile);
            ObsCookiesFilePath.SetValidateNotifyError(IsExitisFile);
            EdgeCommand   = new[] { EdgeLocalStateFilePath.ObserveHasErrors, EdgeCookiesFilePath.ObserveHasErrors, ObsCookiesFilePath.ObserveHasErrors }.CombineLatestValuesAreAllFalse().ToReactiveCommand <Models.CommandParameter>();
            ChromeCommand = new[] { ChromeLocalStateFilePath.ObserveHasErrors, ChromeCookiesFilePath.ObserveHasErrors, ObsCookiesFilePath.ObserveHasErrors }.CombineLatestValuesAreAllFalse().ToReactiveCommand <Models.CommandParameter>();

            LocalStateFilePath.SetValidateNotifyError(IsExitisFile);
            SrcCookieFilePath.SetValidateNotifyError(IsExitisFile);
            DestCookieFilePath.SetValidateNotifyError(IsExitisFile);
            HostKey.SetValidateNotifyError(host =>
            {
                if (String.IsNullOrWhiteSpace(host))
                {
                    return("Empty");
                }

                return(null);
            });

            ParamCommand = new[] { LocalStateFilePath.ObserveHasErrors, SrcCookieFilePath.ObserveHasErrors, HostKey.ObserveHasErrors, DestCookieFilePath.ObserveHasErrors }.CombineLatestValuesAreAllFalse().ToReactiveCommand <Models.CommandParameter>();

            EdgeCommand.Subscribe(ExecuteCommand.Execute);
            ChromeCommand.Subscribe(ExecuteCommand.Execute);
            ParamCommand.Subscribe(ExecuteCommand.Execute);

            OkCommand.Subscribe(async _ =>
            {
                Executing.Value = true;

                try
                {
                    await System.Threading.Tasks.Task.Run(() =>
                    {
                        CookieManager.Converter.Convert(Environment.ExpandEnvironmentVariables(Param.LocalStateFilePath), Environment.ExpandEnvironmentVariables(Param.SrcCookieFilePath), Param.HostKey, Environment.ExpandEnvironmentVariables(Param.DestCookieFilePath));
                    });
                }
                catch
                {
                    IsErrorDialogOpen.Value = true;
                }

                Executing.Value    = false;
                IsDialogOpen.Value = false;
            }
                                );

            ExecuteCommand.Subscribe(param =>
            {
                IsDialogOpen.Value = true;
                Param = param;
            });

            CancelCommand.Subscribe(_ => IsDialogOpen.Value = false);

            ErrorOkCommand.Subscribe(_ => IsErrorDialogOpen.Value = false);
        }
Пример #26
0
        void ConfigurationPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            switch (e.PropertyName)
            {
            case "HasChanges":
                CommandManager.InvalidateRequerySuggested();
                SaveCommand.RaiseCanExecuteChanged();
                CancelCommand.RaiseCanExecuteChanged();
                ClearErrorsCommand.RaiseCanExecuteChanged();
                if (Configuration.HasChanges)
                {
                    SaveSuccess = false;
                }
                break;

            case "HasError":
                CommandManager.InvalidateRequerySuggested();
                SaveCommand.RaiseCanExecuteChanged();
                CancelCommand.RaiseCanExecuteChanged();
                ClearErrorsCommand.RaiseCanExecuteChanged();
                break;

            default:
                break;
            }
        }
Пример #27
0
 public override void PrivateChatProcessing(Message message, ref bool continuation)
 {
     try
     {
         base.PrivateChatProcessing(message, ref continuation);
         long chatId = message.Chat.Id;
         if (message.Text != null && message.Text.ToLower().Equals(CancelCommand.ToLower()))
         {
             ClearUnderChatMenu(chatId, "Принято!");
             SendDefaultMenu(chatId);
             mods.TryRemove(chatId, out Mode m);
             return;
         }
         if (mods.TryGetValue(chatId, out Mode mode))
         {
             Match TokenChecking = TokenParsing.Match(message.Text);
             if (TokenChecking.Success)
             {
                 logger.Info("Добавляем бота с токеном " + TokenChecking.Groups[1].Value);
                 AddBot(TokenChecking.Groups[1].Value, mode);
                 ClearUnderChatMenu(message.Chat.Id, "Бот успешно создан!");
                 SendDefaultMenu(message.Chat.Id);
                 return;
             }
             else
             {
                 sender_to_tg.Put(factory.CreateMessage(message.Chat.Id, "Пришлите пожалуйста корректный токен в формате\n\n 1234567:AAAAAAAdsdd"));
                 return;
             }
         }
         SendDefaultMenu(chatId);
     }
     catch (Exception ex) { logger.Error(ex); }
 }
Пример #28
0
        private async void Start()
        {
            try
            {
                CancellationTokenSource = new CancellationTokenSource();

                RunTask = true;
                StartCommand.RaiseCanExecuteChanged();
                CancelCommand.RaiseCanExecuteChanged();

                var tasks = new List <Task>();

                tasks.AddRange(new List <Task>()
                {
                    InitializeProgressBar(ProgressBarOneText, new Progress <int>(p => ProgressBarOneValue     = p), CancellationTokenSource.Token),
                    InitializeProgressBar(ProgressBarTwoText, new Progress <int>(p => ProgressBarTwoValue     = p), CancellationTokenSource.Token),
                    InitializeProgressBar(ProgressBarThreeText, new Progress <int>(p => ProgressBarThreeValue = p), CancellationTokenSource.Token),
                });

                await Task.WhenAll(tasks);
            }
            catch (OperationCanceledException)
            {
            }
            finally
            {
                RunTask = false;
                StartCommand.RaiseCanExecuteChanged();
                CancelCommand.RaiseCanExecuteChanged();
            }
        }
Пример #29
0
        public async Task WrappedDelegateCompleted_EntersCanceledState()
        {
            var          command = new CancelCommand();
            var          observedCancellationToken = new CancellationToken();
            object       observedSender            = null;
            bool         observedCanExecute        = true;
            EventHandler subscription = (s, _) =>
            {
                observedSender     = s;
                observedCanExecute = ((ICommand)command).CanExecute(null);
            };
            var ready   = new TaskCompletionSource <object>();
            var release = new TaskCompletionSource <object>();

            var task = command.Wrap(async token =>
            {
                observedCancellationToken = token;
                ready.SetResult(null);
                await release.Task;
            })();
            await ready.Task;

            ((ICommand)command).CanExecuteChanged += subscription;

            release.SetResult(null);
            await task;

            Assert.True(observedCancellationToken.IsCancellationRequested);
            Assert.False(((ICommand)command).CanExecute(null));
            Assert.AreSame(command, observedSender);
            Assert.False(observedCanExecute);

            ((ICommand)command).CanExecuteChanged -= subscription;
        }
Пример #30
0
        private async Task DoExecuteAsync(object parameter)
        {
            await Task.Factory.StartNew(p =>
            {
                // Invoke the action.
                InvokeAction(p);

                ReportProgress(() =>
                {
                    // We are no longer executing.
                    IsExecuting = false;

                    // If we were cancelled, invoke the cancelled event - otherwise invoke executed.
                    if (IsCancellationRequested)
                    {
                        InvokeCancelled(new CommandEventArgs {
                            Parameter = p
                        });
                    }
                    else
                    {
                        InvokeExecuted(new CommandEventArgs {
                            Parameter = p
                        });
                    }

                    CancelCommand.NotifyCanExecuteChanged();
                });
            },
                                        parameter,
                                        _token);
        }
Пример #31
0
 private static Message Convert(string exchangeCode, CancelCommand cancelCommand)
 {
     CancelMessage cancelMessage = new CancelMessage(exchangeCode,cancelCommand.TransactionID,
         (TransactionError)cancelCommand.ErrorCode, (iExchange.Common.CancelReason)cancelCommand.CancelReason);
     return cancelMessage;
 }