protected IssueModifyViewModel(string username, string repository) { var alertDialogService = Locator.Current.GetService <IAlertDialogService>(); Username = username; Repository = repository; Kind = "bug"; Priority = "major"; Milestones = new IssueMilestonesViewModel(username, repository); Versions = new IssueVersionsViewModel(username, repository); Components = new IssueComponentsViewModel(username, repository); Assignee = new IssueAssigneeViewModel(username, repository); SaveCommand = ReactiveCommand.CreateFromTask( t => Save(), this.WhenAnyValue(x => x.IssueTitle).Select(y => !string.IsNullOrEmpty(y))); SaveCommand.BindCommand(DismissCommand); DiscardCommand = ReactiveCommand.CreateFromTask(async t => { if (Content?.Length > 0 || IssueTitle?.Length > 0) { var result = await alertDialogService.PromptYesNo( "Discard Changes", "Are you sure you want to discard your changes?"); if (!result) { return; } } DismissCommand.ExecuteNow(); }); }
public NewCommentViewModel( Func <string, Task> doneAction, IAlertDialogService alertDialogService = null) { alertDialogService = alertDialogService ?? Locator.Current.GetService <IAlertDialogService>(); DoneCommand = ReactiveCommand.CreateFromTask(async _ => { await doneAction(Text); DismissCommand.ExecuteNow(); Text = string.Empty; }, this.WhenAnyValue(x => x.Text).Select(x => x?.Length > 0)); DiscardCommand = ReactiveCommand.CreateFromTask(async _ => { if (Text?.Length > 0) { var result = await alertDialogService.PromptYesNo( "Discard Comment", "Are you sure you want to discard this comment?"); if (!result) { return; } } Text = string.Empty; DismissCommand.ExecuteNow(); }); }
protected override async Task Save() { if (string.IsNullOrEmpty(Title)) { throw new Exception("Unable to save the issue: you must provide a title!"); } try { var assignedTo = AssignedTo == null ? null : AssignedTo.Login; int?milestone = null; if (Milestone != null) { milestone = Milestone.Number; } var labels = Labels.Select(x => x.Name).ToArray(); var content = Content ?? string.Empty; var data = await _applicationService.Client.ExecuteAsync(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues.Create(Title, content, assignedTo, milestone, labels)); _createdIssueSubject.OnNext(data.Data); DismissCommand.ExecuteIfCan(); } catch (Exception e) { throw new Exception("Unable to save new issue! Please try again.", e); } }
public GistCreateViewModel(IApplicationService applicationService) { _applicationService = applicationService; Title = "Create Gist"; Files = new Dictionary <string, string>(); SaveCommand = ReactiveCommand.CreateAsyncTask(async t => { if (_files == null || _files.Count == 0) { throw new Exception("You cannot create a Gist without atleast one file! Please correct and try again."); } var createGist = new GistCreateModel { Description = Description, Public = IsPublic, Files = Files.ToDictionary(x => x.Key, x => new GistCreateModel.File { Content = x.Value }) }; var request = _applicationService.Client.AuthenticatedUser.Gists.CreateGist(createGist); _createdGistSubject.OnNext((await _applicationService.Client.ExecuteAsync(request)).Data); DismissCommand.ExecuteIfCan(); }); }
protected MarkdownComposerViewModel(IStatusIndicatorService status, IAlertDialogService alert, IJsonHttpClientService jsonClient) { var saveCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.Text).Select(x => !string.IsNullOrEmpty(x)), t => Save()); saveCommand.IsExecuting.Where(x => x).Subscribe(_ => status.Show("Saving...")); saveCommand.IsExecuting.Where(x => !x).Subscribe(_ => status.Hide()); saveCommand.Subscribe(x => DismissCommand.ExecuteIfCan()); SaveCommand = saveCommand; PostToImgurCommand = ReactiveCommand.CreateAsyncTask(async data => { var uploadData = data as byte[]; if (uploadData == null) { throw new Exception("There is no data to upload!"); } return(await jsonClient.Post <ImgurModel>("https://api.imgur.com/3/image", new { image = Convert.ToBase64String(uploadData) }, new Dictionary <string, string> { { "Authorization", "Client-ID " + AuthorizationClientId } })); }); PostToImgurCommand.IsExecuting.Where(x => x).Subscribe(_ => status.Show("Uploading...")); PostToImgurCommand.IsExecuting.Where(x => !x).Subscribe(_ => status.Hide()); PostToImgurCommand.ThrownExceptions.SubscribeSafe(e => alert.Alert("Error", "Unable to upload image: " + e.Message)); }
public LoginViewModel(INetworkActivityService networkActivity) { LoginCommand = ReactiveCommand.CreateAsyncTask(async t => { var account = new Account(); var connection = new Octokit.Connection(new Octokit.ProductHeaderValue("RepoStumble")); var client = new Octokit.OauthClient(connection); var token = await client.CreateAccessToken(new Octokit.OauthTokenRequest(ClientId, ClientSecret, LoginCode)); connection.Credentials = new Octokit.Credentials(token.AccessToken); var githubClient = new Octokit.GitHubClient(connection); var info = await githubClient.User.Current(); account.AvatarUrl = info.AvatarUrl; account.Username = info.Login; account.Fullname = info.Name; account.OAuth = token.AccessToken; account.Save(); DismissCommand.ExecuteIfCan(); }); LoginCommand.IsExecuting.Skip(1).Where(x => x).Subscribe(x => networkActivity.PushNetworkActive()); LoginCommand.IsExecuting.Skip(1).Where(x => !x).Subscribe(x => networkActivity.PopNetworkActive()); }
protected override async Task Save() { if (string.IsNullOrEmpty(Title)) throw new Exception("Issue must have a title!"); try { var assignedTo = AssignedTo == null ? null : AssignedTo.Login; int? milestone = null; if (Milestone != null) milestone = Milestone.Number; var labels = Labels.Select(x => x.Name).ToArray(); var content = Content ?? string.Empty; var state = IsOpen ? "open" : "closed"; var retried = false; // For some reason github needs to try again during an internal server error tryagain: try { var data = await _applicationService.Client.ExecuteAsync(_applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[Issue.Number].Update(Title, content, state, assignedTo, milestone, labels)); Issue = data.Data; } catch (GitHubSharp.InternalServerException) { if (retried) throw; //Do nothing. Something is wrong with github's service retried = true; goto tryagain; } DismissCommand.ExecuteIfCan(); } catch (Exception e) { throw new Exception("Unable to save the issue! Please try again", e); } // //There is a wierd bug in GitHub when editing an existing issue and the assignedTo is null // catch (GitHubSharp.InternalServerException) // { // if (ExistingIssue != null && assignedTo == null) // tryEditAgain = true; // else // throw; // } // // if (tryEditAgain) // { // var response = await Application.Client.ExecuteAsync(Application.Client.Users[Username].Repositories[RepoSlug].Issues[ExistingIssue.Number].Update(title, content, state, assignedTo, milestone, labels)); // model = response.Data; // } }
public EditFileViewModel(ISessionService sessionService, IAlertDialogFactory alertDialogFactory) { Title = "Edit"; this.WhenAnyValue(x => x.Path) .IsNotNull() .Subscribe(x => CommitMessage = "Updated " + x.Substring(x.LastIndexOf('/') + 1)); this.WhenAnyValue(x => x.Text) .Subscribe(x => _lastEdit = DateTime.Now); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var path = Path; if (!path.StartsWith("/", StringComparison.Ordinal)) { path = "/" + path; } var request = sessionService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContentFile(path, Branch ?? "master"); request.UseCache = false; var data = await sessionService.Client.ExecuteAsync(request); BlobSha = data.Data.Sha; var content = Convert.FromBase64String(data.Data.Content); Text = System.Text.Encoding.UTF8.GetString(content, 0, content.Length) ?? string.Empty; _lastLoad = DateTime.Now; }); GoToCommitMessageCommand = ReactiveCommand.Create(); SaveCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.CommitMessage).Select(x => !string.IsNullOrEmpty(x)), async _ => { var path = Path.TrimStart('/'); var request = new Octokit.UpdateFileRequest(CommitMessage, Text, BlobSha) { Branch = Branch }; using (alertDialogFactory.Activate("Commiting...")) return(await sessionService.GitHubClient.Repository.Content.UpdateFile(RepositoryOwner, RepositoryName, path, request)); }); SaveCommand.Subscribe(x => Dismiss()); DismissCommand = ReactiveCommand.CreateAsyncTask(async t => { if (string.IsNullOrEmpty(Text)) { return(true); } if (_lastEdit <= _lastLoad) { return(true); } return(await alertDialogFactory.PromptYesNo("Discard Edit?", "Are you sure you want to discard these changes?")); }); DismissCommand.Where(x => x).Subscribe(_ => Dismiss()); }
public CommitMessageViewModel(IApplicationService applicationService) { SaveCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.Message).Select(x => !string.IsNullOrEmpty(x)), async _ => { var request = applicationService.Client.Users[Username].Repositories[Repository] .UpdateContentFile(Path, Message, Text, BlobSha, Branch); var response = await applicationService.Client.ExecuteAsync(request); _contentSubject.OnNext(response.Data); DismissCommand.ExecuteIfCan(); }); }
public AccountsViewModel(IAccountsService accountsService) { _accountsService = accountsService; Title = "Accounts"; _accounts = new ReactiveList <GitHubAccount>(accountsService.OrderBy(x => x.Username)); this.WhenActivated(d => _accounts.Reset(accountsService.OrderBy(x => x.Username))); Accounts = _accounts.CreateDerivedCollection(CreateAccountItem); this.WhenAnyValue(x => x.ActiveAccount) .Subscribe(x => { foreach (var account in Accounts) { account.Selected = Equals(account.Account, x); } }); DeleteAccountCommand = ReactiveCommand.Create(); DeleteAccountCommand.OfType <GitHubAccount>().Subscribe(x => { if (Equals(accountsService.ActiveAccount, x)) { ActiveAccount = null; } accountsService.Remove(x); _accounts.Remove(x); }); LoginCommand = ReactiveCommand.Create(); LoginCommand.OfType <GitHubAccount>().Subscribe(x => { if (Equals(accountsService.ActiveAccount, x)) { DismissCommand.ExecuteIfCan(); } else { ActiveAccount = x; MessageBus.Current.SendMessage(new LogoutMessage()); DismissCommand.ExecuteIfCan(); } }); DismissCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.ActiveAccount).Select(x => x != null)) .WithSubscription(x => base.DismissCommand.ExecuteIfCan(x)); GoToAddAccountCommand = ReactiveCommand.Create() .WithSubscription(_ => ShowViewModel(CreateViewModel <NewAccountViewModel>())); }
public PurchaseProViewModel(IFeaturesService featuresService) { var purchaseCommand = ReactiveCommand.CreateAsyncTask(x => featuresService.EnableProEdition()); purchaseCommand.Subscribe(_ => DismissCommand.ExecuteIfCan()); PurchaseCommand = purchaseCommand; var restoreCommand = ReactiveCommand.CreateAsyncTask(x => featuresService.RestorePurchase()); restoreCommand.Subscribe(_ => DismissCommand.ExecuteIfCan()); RestoreCommand = restoreCommand; GetPrice(featuresService); }
public MyIssuesFilterViewModel(IActionMenuFactory actionMenu) { Title = "Filter"; State = IssueState.Open; SortType = IssueSort.None; FilterType = IssueFilterState.All; SaveCommand = ReactiveCommand.CreateAsyncTask(_ => Task.FromResult(new MyIssuesFilterModel(FilterType, State, SortType, Labels, Ascending))); SaveCommand.Subscribe(_ => DismissCommand.ExecuteIfCan()); DismissCommand = ReactiveCommand.Create().WithSubscription(_ => Dismiss()); SelectStateCommand = ReactiveCommand.CreateAsyncTask(async sender => { var options = Enum.GetValues(typeof(IssueState)).Cast <IssueState>().ToList(); var picker = actionMenu.CreatePicker(); foreach (var option in options) { picker.Options.Add(option.Humanize()); } picker.SelectedOption = options.IndexOf(State); var ret = await picker.Show(sender); State = options[ret]; }); SelectSortCommand = ReactiveCommand.CreateAsyncTask(async sender => { var options = Enum.GetValues(typeof(IssueSort)).Cast <IssueSort>().ToList(); var picker = actionMenu.CreatePicker(); foreach (var option in options) { picker.Options.Add(option.Humanize()); } picker.SelectedOption = options.IndexOf(SortType); var ret = await picker.Show(sender); SortType = options[ret]; }); SelectFilterTypeCommand = ReactiveCommand.CreateAsyncTask(async sender => { var options = Enum.GetValues(typeof(IssueFilterState)).Cast <IssueFilterState>().ToList(); var picker = actionMenu.CreatePicker(); foreach (var option in options) { picker.Options.Add(option.Humanize()); } picker.SelectedOption = options.IndexOf(FilterType); var ret = await picker.Show(sender); FilterType = options[ret]; }); }
public IssueLabelsViewModel(IApplicationService applicationService) { Labels = new ReactiveList <LabelModel>(); SelectedLabels = new ReactiveList <LabelModel>(); SelectLabelsCommand = ReactiveCommand.CreateAsyncTask(async t => { var selectedLabels = t as IEnumerable <LabelModel>; if (selectedLabels != null) { SelectedLabels.Reset(selectedLabels); } //If nothing has changed, dont do anything... if (OriginalLabels != null && OriginalLabels.Count() == SelectedLabels.Count() && OriginalLabels.Intersect(SelectedLabels).Count() == SelectedLabels.Count()) { DismissCommand.ExecuteIfCan(); return; } if (SaveOnSelect) { try { var labels = (SelectedLabels != null && SelectedLabels.Count > 0) ? SelectedLabels.Select(y => y.Name).ToArray() : null; var updateReq = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId] .UpdateLabels(labels); await applicationService.Client.ExecuteAsync(updateReq); } catch (Exception e) { throw new Exception("Unable to save labels! Please try again.", e); } } DismissCommand.ExecuteIfCan(); }); LoadCommand = ReactiveCommand.CreateAsyncTask(t => Labels.SimpleCollectionLoad( applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Labels.GetAll(), t as bool?)); }
protected DefaultStartupViewModel(IAccountsService accountsService, Type menuViewModelType) { StartupViews = new ReactiveCollection <string>(); AccountsService = accountsService; SelectedStartupView = AccountsService.ActiveAccount.DefaultStartupView; this.WhenAnyValue(x => x.SelectedStartupView).Skip(1).Subscribe(x => { AccountsService.ActiveAccount.DefaultStartupView = x; AccountsService.Update(AccountsService.ActiveAccount); DismissCommand.ExecuteIfCan(); }); StartupViews.Reset(from p in menuViewModelType.GetProperties() let attr = p.GetCustomAttributes(typeof(PotentialStartupViewAttribute), true) where attr.Length == 1 && attr[0] is PotentialStartupViewAttribute select((PotentialStartupViewAttribute)attr[0]).Name); }
public DefaultStartupViewModel(IAccountsService accountsService) { AccountsService = accountsService; var menuViewModelType = typeof(MenuViewModel); SelectedStartupView = AccountsService.ActiveAccount.DefaultStartupView; this.WhenAnyValue(x => x.SelectedStartupView).Skip(1).Subscribe(x => { AccountsService.ActiveAccount.DefaultStartupView = x; AccountsService.Update(AccountsService.ActiveAccount); DismissCommand.ExecuteIfCan(); }); StartupViews = new ReactiveList <string>(from p in menuViewModelType.GetRuntimeProperties() let attr = p.GetCustomAttributes(typeof(PotentialStartupViewAttribute), true).ToList() where attr.Count == 1 && attr[0] is PotentialStartupViewAttribute select((PotentialStartupViewAttribute)attr[0]).Name); }
public AddInterestViewModel(IApplicationService applicationService, IJsonSerializationService jsonSerializationService) { DoneCommand = ReactiveCommand.CreateAsyncTask(async _ => { if (SelectedLanguage == null) { throw new Exception("You must select a language for your interest!"); } if (string.IsNullOrEmpty(Keyword)) { throw new Exception("Please specify a keyword to go with your interest!"); } applicationService.Account.Interests.Insert(new Interest { Language = _selectedLanguage.Name, LanguageId = _selectedLanguage.Slug, Keyword = _keyword }); await DismissCommand.ExecuteAsync(); }); GoToLanguagesCommand = ReactiveCommand.Create(); GoToLanguagesCommand.Subscribe(_ => { var vm = CreateViewModel <LanguagesViewModel>(); vm.SelectedLanguage = SelectedLanguage; vm.WhenAnyValue(x => x.SelectedLanguage).Skip(1).Subscribe(x => { SelectedLanguage = x; vm.DismissCommand.ExecuteIfCan(); }); ShowViewModel(vm); }); var str = System.IO.File.ReadAllText(PopularInterestsPath, System.Text.Encoding.UTF8); PopularInterests = new ReactiveList <PopularInterest>(jsonSerializationService.Deserialize <List <PopularInterest> >(str)); }
public FeedbackComposerViewModel(IApplicationService applicationService, IImgurService imgurService, IMediaPickerService mediaPicker, IStatusIndicatorService statusIndicatorService, IAlertDialogService alertDialogService) { this.WhenAnyValue(x => x.IsFeature).Subscribe(x => Title = x ? "New Feature" : "Bug Report"); SubmitCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.Subject).Select(x => !string.IsNullOrEmpty(x)), async _ => { if (string.IsNullOrEmpty(Subject)) { throw new ArgumentException(string.Format("You must provide a title for this {0}!", IsFeature ? "feature" : "bug")); } var labels = await applicationService.Client.ExecuteAsync(applicationService.Client.Users[CodeHubOwner].Repositories[CodeHubName].Labels.GetAll()); var createLabels = labels.Data.Where(x => string.Equals(x.Name, IsFeature ? "feature request" : "bug", StringComparison.OrdinalIgnoreCase)).Select(x => x.Name).Distinct(); var request = applicationService.Client.Users[CodeHubOwner].Repositories[CodeHubName].Issues.Create(Subject, Description, null, null, createLabels.ToArray()); var createdIssue = await applicationService.Client.ExecuteAsync(request); _createdIssueSubject.OnNext(createdIssue.Data); DismissCommand.ExecuteIfCan(); }); PostToImgurCommand = ReactiveCommand.CreateAsyncTask(async _ => { var photo = await mediaPicker.PickPhoto(); var memoryStream = new MemoryStream(); await photo.Save(Splat.CompressedBitmapFormat.Jpeg, 0.8f, memoryStream); using (statusIndicatorService.Activate("Uploading...")) { var model = await imgurService.SendImage(memoryStream.ToArray()); if (model == null || model.Data == null || model.Data.Link == null) { throw new InvalidOperationException("Unable to upload to Imgur. Please try again later."); } return(model.Data.Link); } }); PostToImgurCommand.ThrownExceptions .Where(x => !(x is TaskCanceledException)) .Subscribe(x => alertDialogService.Alert("Upload Error", x.Message)); }
public IssueMilestonesViewModel(IApplicationService applicationService) { Milestones = new ReactiveList <MilestoneModel>(); SelectMilestoneCommand = ReactiveCommand.CreateAsyncTask(async t => { var milestone = t as MilestoneModel; if (milestone != null) { SelectedMilestone = milestone; } if (SaveOnSelect) { try { int?milestoneNumber = null; if (SelectedMilestone != null) { milestoneNumber = SelectedMilestone.Number; } var updateReq = applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId].UpdateMilestone(milestoneNumber); await applicationService.Client.ExecuteAsync(updateReq); } catch (Exception e) { throw new Exception("Unable to to save milestone! Please try again.", e); } } DismissCommand.ExecuteIfCan(); }); LoadCommand = ReactiveCommand.CreateAsyncTask(t => Milestones.SimpleCollectionLoad( applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Milestones.GetAll(), t as bool?)); }
public AccountsViewModel(IAccountsService accountsService) { _accountsService = accountsService; Accounts = new ReactiveList <IAccount>(accountsService); LoginCommand = new ReactiveCommand(); GoToAddAccountCommand = new ReactiveCommand(); DeleteAccountCommand = new ReactiveCommand(); DeleteAccountCommand.OfType <IAccount>().Subscribe(x => { if (Equals(accountsService.ActiveAccount, x)) { ActiveAccount = null; } accountsService.Remove(x); Accounts.Remove(x); }); LoginCommand.OfType <IAccount>().Subscribe(x => { if (Equals(accountsService.ActiveAccount, x)) { DismissCommand.ExecuteIfCan(); } else { ActiveAccount = x; MessageBus.Current.SendMessage(new LogoutMessage()); DismissCommand.ExecuteIfCan(); } }); GoToAddAccountCommand.Subscribe(_ => ShowViewModel(CreateViewModel(typeof(IAddAccountViewModel)))); LoadCommand = new ReactiveCommand(); LoadCommand.Subscribe(x => Accounts.Reset(accountsService)); }
public IssueAssignedToViewModel(IApplicationService applicationService) { _applicationService = applicationService; Users = new ReactiveList<BasicUserModel>(); SelectUserCommand = ReactiveCommand.CreateAsyncTask(async t => { var selectedUser = t as BasicUserModel; if (selectedUser != null) SelectedUser = selectedUser; if (SaveOnSelect) { var assignee = SelectedUser != null ? SelectedUser.Login : null; var updateReq = _applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId].UpdateAssignee(assignee); await _applicationService.Client.ExecuteAsync(updateReq); } DismissCommand.ExecuteIfCan(); }); LoadCommand = ReactiveCommand.CreateAsyncTask(t => Users.SimpleCollectionLoad(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetAssignees(), t as bool?)); }
public IssueLabelsViewModel(IApplicationService applicationService, IGraphicService graphicService) { var labels = new ReactiveList <LabelModel>(); SelectedLabels = new ReactiveList <LabelModel>(); Labels = labels.CreateDerivedCollection(x => { var vm = new IssueLabelItemViewModel(graphicService, x); vm.SelectCommand.Subscribe(_ => { var selected = SelectedLabels.FirstOrDefault(y => string.Equals(y.Name, x.Name)); if (selected != null) { SelectedLabels.Remove(selected); vm.Selected = false; } else { SelectedLabels.Add(x); vm.Selected = true; } }); return(vm); }); SelectLabelsCommand = ReactiveCommand.CreateAsyncTask(async t => { var selectedLabels = t as IEnumerable <LabelModel>; if (selectedLabels != null) { SelectedLabels.Reset(selectedLabels); } //If nothing has changed, dont do anything... if (OriginalLabels != null && OriginalLabels.Count() == SelectedLabels.Count() && OriginalLabels.Intersect(SelectedLabels).Count() == SelectedLabels.Count()) { DismissCommand.ExecuteIfCan(); return; } if (SaveOnSelect) { // try // { // var labels = (SelectedLabels != null && SelectedLabels.Count > 0) // ? SelectedLabels.Select(y => y.Name).ToArray() : null; // var updateReq = // applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Issues[IssueId] // .UpdateLabels(labels); // await applicationService.Client.ExecuteAsync(updateReq); // } // catch (Exception e) // { // throw new Exception("Unable to save labels! Please try again.", e); // } } DismissCommand.ExecuteIfCan(); }); LoadCommand = ReactiveCommand.CreateAsyncTask(t => labels.LoadAll(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Labels.GetAll())); }
public ICommand BuildCommand(string command, IUser author, IMessageChannel channel, IGuild guild, params string[] parameters) { ICommand _command = null; switch (command) { case CommandNames.exit: _command = new ExitCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.update: _command = new UpdateCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.restart: _command = new RestartCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.help: _command = new HelpCommand(author, _config, channel, _messageWriter, _commandsInfo, _validationHandler, parameters); break; case CommandNames.version: _command = new VersionCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.random: _command = new RandomCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.github: _command = new GithubCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.uptime: _command = new UptimeCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.color: _command = new ColorCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.flipcoin: _command = new FlipcoinCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.roll: _command = new RollCommand(author, _config, channel, _messageWriter, _validationHandler, parameters); break; case CommandNames.purge: _command = new PurgeCommand(author, _config, channel, _messageWriter, _connectionHandler, _validationHandler, parameters); break; case CommandNames.summon: _command = new SummonCommand(author, _config, channel, _messageWriter, _audioService, guild, _validationHandler, parameters); break; case CommandNames.dismiss: _command = new DismissCommand(author, _config, channel, _messageWriter, _audioService, guild, _validationHandler, parameters); break; case CommandNames.play: _command = new PlayCommand(author, _config, channel, _messageWriter, _audioService, guild, _validationHandler, parameters); break; default: break; } return(_command); }
public IssueViewModel( string username, string repository, int issueId, IApplicationService applicationService = null, IMarkdownService markdownService = null, IMessageService messageService = null, IAlertDialogService alertDialogService = null, IActionMenuService actionMenuService = null) { _applicationService = applicationService = applicationService ?? Locator.Current.GetService <IApplicationService>(); messageService = messageService ?? Locator.Current.GetService <IMessageService>(); markdownService = markdownService ?? Locator.Current.GetService <IMarkdownService>(); alertDialogService = alertDialogService ?? Locator.Current.GetService <IAlertDialogService>(); actionMenuService = actionMenuService ?? Locator.Current.GetService <IActionMenuService>(); Title = "Issue #" + issueId; Username = username; Repository = repository; IssueId = issueId; GoToWebCommand = ReactiveCommand.Create <string>( url => NavigateTo(new WebBrowserViewModel(url))); GoToReporterCommand = ReactiveCommand.Create( () => NavigateTo(new UserViewModel(Issue.ReportedBy.Username)), this.WhenAnyValue(x => x.Issue.ReportedBy.Username).Select(x => x != null)); GoToAssigneeCommand = ReactiveCommand.Create( () => NavigateTo(new UserViewModel(Issue.Responsible.Username)), this.WhenAnyValue(x => x.Issue.Responsible.Username).Select(x => x != null)); GoToEditCommand = ReactiveCommand.Create( () => NavigateTo(new IssueEditViewModel(username, repository, Issue)), this.WhenAnyValue(x => x.Issue).Select(x => x != null)); this.WhenAnyValue(x => x.Issue) .Select(x => x?.Responsible?.Username ?? "Unassigned") .ToProperty(this, x => x.Assigned, out _assigned, "Unassigned"); this.WhenAnyValue(x => x.Issue.Content) .Select(x => string.IsNullOrEmpty(x) ? null : markdownService.ConvertMarkdown(x)) .ToProperty(this, x => x.Description, out _description); this.WhenAnyValue(x => x.Description) .Select(x => !string.IsNullOrEmpty(x)) .ToProperty(this, x => x.ShowDescription, out _showDescription); Comments = _comments.CreateDerivedCollection(x => new CommentItemViewModel(x.AuthorInfo.Username, new Utils.Avatar(x.AuthorInfo.Avatar), x.UtcCreatedOn.Humanize(), markdownService.ConvertMarkdown(x.Content))); LoadCommand = ReactiveCommand.CreateFromTask(async t => { var issueTask = applicationService.Client.Issues.Get(username, repository, issueId); applicationService.Client.Issues.GetComments(username, repository, issueId) .ToBackground(x => _comments.Reset(x.Where(y => !string.IsNullOrEmpty(y.Content)))); Issue = await issueTask; }); DeleteCommand = ReactiveCommand.CreateFromTask(async _ => { try { var prompt = await alertDialogService.PromptYesNo( "Are you sure?", "You are about to permanently delete issue #" + Issue.LocalId + "."); if (prompt) { await applicationService.Client.Issues.Delete(username, repository, Issue.LocalId); messageService.Send(new IssueDeleteMessage(Issue)); DismissCommand.ExecuteNow(); } } catch (Exception e) { this.Log().ErrorException("Error deleting issue", e); } }); ShowMenuCommand = ReactiveCommand.CreateFromTask(sender => { var menu = actionMenuService.Create(); menu.AddButton("Edit", _ => GoToEditCommand.ExecuteNow()); menu.AddButton("Delete", _ => DeleteCommand.ExecuteNow()); return(menu.Show(sender)); }); _issueMessageBus = messageService.Listen <IssueUpdateMessage>(x => { if (x.Issue.LocalId == issueId) { Issue = x.Issue; } }); }
public LoginViewModel(ILoginService loginFactory, IAccountsService accountsService, IActionMenuService actionMenuService, IStatusIndicatorService statusIndicatorService, IAlertDialogService alertDialogService) { _loginFactory = loginFactory; Title = "Login"; GoToOldLoginWaysCommand = ReactiveCommand.Create(); GoToOldLoginWaysCommand.Subscribe(_ => ShowViewModel(CreateViewModel <AddAccountViewModel>())); var loginCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.Code).Select(x => !string.IsNullOrEmpty(x)), _ => Login(Code)); loginCommand.Subscribe(x => accountsService.ActiveAccount = x); loginCommand.Subscribe(x => MessageBus.Current.SendMessage(new LogoutMessage())); LoginCommand = loginCommand; ShowLoginOptionsCommand = ReactiveCommand.CreateAsyncTask(t => { var actionMenu = actionMenuService.Create(Title); actionMenu.AddButton("Login via BASIC", GoToOldLoginWaysCommand); return(actionMenu.Show()); }); LoginCommand.IsExecuting.Skip(1).Subscribe(x => { if (x) { statusIndicatorService.Show("Logging in..."); } else { statusIndicatorService.Hide(); } }); _loginUrl = this.WhenAnyValue(x => x.WebDomain) .IsNotNull() .Select(x => x.TrimEnd('/')) .Select(x => string.Format(x + "/login/oauth/authorize?client_id={0}&redirect_uri={1}&scope={2}", ClientId, Uri.EscapeDataString(RedirectUri), Uri.EscapeDataString("user,repo,notifications,gist"))) .ToProperty(this, x => x.LoginUrl); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { if (IsEnterprise && string.IsNullOrEmpty(WebDomain)) { var response = await alertDialogService.PromptTextBox("Enterprise URL", "Please enter the webpage address for the GitHub Enterprise installation", DefaultWebDomain, "Ok"); WebDomain = response; } else { WebDomain = DefaultWebDomain; } }); LoadCommand.ThrownExceptions.Take(1).Subscribe(x => DismissCommand.ExecuteIfCan()); }