public SourceViewModel(IApplicationService applicationService, IAccountsService accountsService, IFilesystemService filesystemService) : base(accountsService) { GoToEditCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.SourceItem, x => x.TrueBranch).Select(x => x.Item1 != null && x.Item2)); GoToEditCommand.Subscribe(_ => { var vm = CreateViewModel <EditSourceViewModel>(); vm.Path = Path; vm.Branch = Branch; vm.Username = Username; vm.Repository = Repository; ShowViewModel(vm); }); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { string filepath; string mime; using (var stream = filesystemService.CreateTempFile(out filepath)) { mime = await applicationService.Client.DownloadRawResource2(GitUrl, stream) ?? string.Empty; } // We can force a binary representation if it was passed during init. In which case we don't care to figure out via the mime. var isBinary = !mime.Contains("charset"); var fileUri = new Uri(filepath); SourceItem = new FileSourceItemViewModel(fileUri, ForceBinary || isBinary); }); }
public ChangesetDiffViewModel(IApplicationService applicationService, IFilesystemService filesystemService) { Comments = new ReactiveList <CommentModel>(); GoToCommentCommand = ReactiveCommand.Create(); GoToCommentCommand.OfType <int?>().Subscribe(line => { var vm = CreateViewModel <CommentViewModel>(); ReactiveUI.Legacy.ReactiveCommandMixins.RegisterAsyncTask(vm.SaveCommand, async t => { var req = applicationService.Client.Users[Username].Repositories[Repository].Commits[Branch].Comments.Create(vm.Comment, Filename, line); var response = await applicationService.Client.ExecuteAsync(req); Comments.Add(response.Data); vm.DismissCommand.ExecuteIfCan(); }); ShowViewModel(vm); }); this.WhenAnyValue(x => x.Filename).Subscribe(x => { if (string.IsNullOrEmpty(x)) { Title = "Diff"; } else { _actualFilename = Path.GetFileName(Filename) ?? Filename.Substring(Filename.LastIndexOf('/') + 1); Title = _actualFilename; } }); _loadCommand = ReactiveCommand.CreateAsyncTask(async t => { var branch = applicationService.Client.Users[Username].Repositories[Repository].Commits[Branch]; //Make sure we have this information. If not, go get it if (CommitFile == null) { var data = await applicationService.Client.ExecuteAsync(branch.Get()); CommitFile = data.Data.Files.First(x => string.Equals(x.Filename, Filename)); } string path; using (var stream = filesystemService.CreateTempFile(out path)) { using (var fs = new StreamWriter(stream)) { fs.Write(CommitFile.Patch); } } SourceItem = new FileSourceItemViewModel { FilePath = path }; await Comments.SimpleCollectionLoad(branch.Comments.GetAll(), t as bool?); }); }
public SourceViewModel(IApplicationService applicationService, IAccountsService accountsService, IFilesystemService filesystemService) { GoToEditCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.SourceItem, x => x.TrueBranch).Select(x => x.Item1 != null && x.Item2)); GoToEditCommand.Subscribe(_ => { var vm = CreateViewModel <EditSourceViewModel>(); vm.Path = CurrentItem.Path; vm.Branch = Branch; vm.Username = Username; vm.Repository = Repository; ShowViewModel(vm); }); Theme = applicationService.Account.CodeEditTheme; this.WhenAnyValue(x => x.Theme).Skip(1).Subscribe(x => { applicationService.Account.CodeEditTheme = x; accountsService.Update(applicationService.Account); }); this.WhenAnyValue(x => x.CurrentItem) .Skip(1) .Where(x => x != null) .Subscribe(_ => LoadCommand.ExecuteIfCan()); _loadCommand = ReactiveCommand.CreateAsyncTask(async t => { var fileName = System.IO.Path.GetFileName(CurrentItem.Name); if (fileName == null) { return; } string filepath; string mime; using (var stream = filesystemService.CreateTempFile(out filepath)) { mime = await applicationService.Client.DownloadRawResource2(CurrentItem.GitUrl, stream) ?? string.Empty; } // We can force a binary representation if it was passed during init. In which case we don't care to figure out via the mime. var isBinary = !mime.Contains("charset"); SourceItem = new FileSourceItemViewModel { FilePath = filepath, IsBinary = (CurrentItem.ForceBinary || isBinary) }; }); SetupRx(); }
public SourceViewModel(IApplicationService applicationService, IAccountsService accountsService, IFilesystemService filesystemService) : base(accountsService) { GoToEditCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.SourceItem, x => x.TrueBranch).Select(x => x.Item1 != null && x.Item2)); GoToEditCommand.Subscribe(_ => { var vm = CreateViewModel <EditSourceViewModel>(); vm.Path = Path; vm.Branch = Branch; vm.Username = RepositoryOwner; vm.Repository = RepositoryName; ShowViewModel(vm); }); this.WhenAnyValue(x => x.Name).Subscribe(x => Title = x ?? string.Empty); _isMarkdown = this.WhenAnyValue(x => x.Path).IsNotNull().Select(x => MarkdownExtensions.Any(Path.EndsWith)).ToProperty(this, x => x.IsMarkdown); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { string filepath; bool isBinary = false; using (var stream = filesystemService.CreateTempFile(out filepath)) { if (MarkdownExtensions.Any(Path.EndsWith)) { var renderedContent = await applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContentFileRendered(Path, Branch); using (var stringWriter = new StreamWriter(stream)) { await stringWriter.WriteAsync(renderedContent); } } else { var mime = await applicationService.Client.DownloadRawResource2(GitUrl, stream) ?? string.Empty; isBinary = !(mime ?? string.Empty).Contains("charset"); } } // We can force a binary representation if it was passed during init. In which case we don't care to figure out via the mime. var fileUri = new Uri(filepath); SourceItem = new FileSourceItemViewModel(fileUri, ForceBinary || isBinary); }); }
public SourceViewModel(ISessionService sessionService, IActionMenuFactory actionMenuFactory, IFilesystemService filesystemService) : base(sessionService) { var canEdit = this.WhenAnyValue(x => x.SourceItem, x => x.TrueBranch, x => x.PushAccess) .Select(x => x.Item1 != null && x.Item2 && !x.Item1.IsBinary && x.Item3.HasValue && x.Item3.Value); GoToEditCommand = ReactiveCommand.Create(canEdit); GoToEditCommand.Subscribe(_ => { var vm = this.CreateViewModel <EditFileViewModel>(); vm.Init(RepositoryOwner, RepositoryName, Path, null, Branch); vm.SaveCommand.Subscribe(x => { GitUrl = x.Content.GitUrl.AbsoluteUri; LoadCommand.ExecuteIfCan(); }); NavigateTo(vm); }); this.WhenAnyValue(x => x.Name).Subscribe(x => Title = x ?? string.Empty); _isMarkdown = this.WhenAnyValue(x => x.Path).IsNotNull().Select(x => MarkdownExtensions.Any(Path.EndsWith)).ToProperty(this, x => x.IsMarkdown); OpenInGitHubCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.HtmlUrl).Select(x => !string.IsNullOrEmpty(x))); OpenInGitHubCommand .Select(_ => this.CreateViewModel <WebBrowserViewModel>()) .Select(x => x.Init(this.HtmlUrl)) .Subscribe(NavigateTo); var canShowMenu = this.WhenAnyValue(x => x.SourceItem).Select(x => x != null); ShowMenuCommand = ReactiveCommand.CreateAsyncTask(canShowMenu, sender => { var menu = actionMenuFactory.Create(); if (GoToEditCommand.CanExecute(null)) { menu.AddButton("Edit", GoToEditCommand); } menu.AddButton("Open With", OpenWithCommand); if (OpenInGitHubCommand.CanExecute(null)) { menu.AddButton("Open in GitHub", OpenInGitHubCommand); } return(menu.Show(sender)); }); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { string filepath; bool isBinary = false; if (!PushAccess.HasValue) { sessionService.GitHubClient.Repository.Get(RepositoryOwner, RepositoryName) .ToBackground(x => PushAccess = x.Permissions.Push); } using (var stream = filesystemService.CreateTempFile(out filepath, Name)) { if (MarkdownExtensions.Any(Path.EndsWith)) { var renderedContent = await sessionService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContentFileRendered(Path, Branch); using (var stringWriter = new StreamWriter(stream)) { await stringWriter.WriteAsync(renderedContent); } } else { if (string.IsNullOrEmpty(GitUrl) || string.IsNullOrEmpty(HtmlUrl)) { var req = sessionService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContentFile(Path, Branch); var data = (await sessionService.Client.ExecuteAsync(req)).Data; GitUrl = data.GitUrl; HtmlUrl = data.HtmlUrl; } var mime = await sessionService.Client.DownloadRawResource2(GitUrl, stream) ?? string.Empty; isBinary = !(mime ?? string.Empty).Contains("charset"); } } // We can force a binary representation if it was passed during init. In which case we don't care to figure out via the mime. var fileUri = new Uri(filepath); SourceItem = new FileSourceItemViewModel(fileUri, ForceBinary || isBinary); }); }
public GistFileViewModel(ISessionService sessionService, ISessionService applicationService, IFilesystemService filesystemService, IActionMenuFactory actionMenuService) : base(sessionService) { this.WhenAnyValue(x => x.Filename) .Select(x => x == null ? "Gist" : x.Substring(x.LastIndexOf('/') + 1)) .Subscribe(x => Title = x); _isMarkdown = this.WhenAnyValue(x => x.GistFile) .IsNotNull() .Select(x => string.Equals(x.Language, MarkdownLanguage, StringComparison.OrdinalIgnoreCase)) .ToProperty(this, x => x.IsMarkdown); ShowMenuCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.SourceItem).Select(x => x != null), sender => { var menu = actionMenuService.Create(); menu.AddButton("Open With", OpenWithCommand); return menu.Show(sender); }); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { if (GistFile == null) { var data = await applicationService.GitHubClient.Gist.Get(_id); GistFile = data.Files[_filename]; } //Check to make sure... if (GistFile == null || GistFile.Content == null) { throw new Exception("Unable to retreive gist!"); } var content = GistFile.Content; if (MarkdownLanguage.Equals(GistFile.Language, StringComparison.OrdinalIgnoreCase)) content = await applicationService.GitHubClient.Miscellaneous.RenderRawMarkdown(content); var gistFileName = System.IO.Path.GetFileName(GistFile.Filename).Trim(); string filePath; using (var stream = filesystemService.CreateTempFile(out filePath, gistFileName)) { using (var fs = new System.IO.StreamWriter(stream)) { fs.Write(content); } } var fileUri = new Uri(filePath); SourceItem = new FileSourceItemViewModel(fileUri, false); }); }
public SourceViewModel(ISessionService sessionService, IActionMenuFactory actionMenuFactory, IFilesystemService filesystemService) : base(sessionService) { var canEdit = this.WhenAnyValue(x => x.SourceItem, x => x.TrueBranch, x => x.PushAccess) .Select(x => x.Item1 != null && x.Item2 && !x.Item1.IsBinary && x.Item3.HasValue && x.Item3.Value); GoToEditCommand = ReactiveCommand.Create(canEdit); GoToEditCommand.Subscribe(_ => { var vm = this.CreateViewModel<EditFileViewModel>(); vm.Path = Path; vm.Branch = Branch; vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.SaveCommand.Subscribe(x => { GitUrl = x.Content.GitUrl.AbsoluteUri; LoadCommand.ExecuteIfCan(); }); NavigateTo(vm); }); this.WhenAnyValue(x => x.Name).Subscribe(x => Title = x ?? string.Empty); _isMarkdown = this.WhenAnyValue(x => x.Path).IsNotNull().Select(x => MarkdownExtensions.Any(Path.EndsWith)).ToProperty(this, x => x.IsMarkdown); OpenInGitHubCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.HtmlUrl).Select(x => !string.IsNullOrEmpty(x))); OpenInGitHubCommand .Select(_ => this.CreateViewModel<WebBrowserViewModel>()) .Select(x => x.Init(this.HtmlUrl)) .Subscribe(NavigateTo); var canShowMenu = this.WhenAnyValue(x => x.SourceItem).Select(x => x != null); ShowMenuCommand = ReactiveCommand.CreateAsyncTask(canShowMenu, sender => { var menu = actionMenuFactory.Create(); if (GoToEditCommand.CanExecute(null)) menu.AddButton("Edit", GoToEditCommand); menu.AddButton("Open With", OpenWithCommand); if (OpenInGitHubCommand.CanExecute(null)) menu.AddButton("Open in GitHub", OpenInGitHubCommand); return menu.Show(sender); }); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { string filepath; bool isBinary = false; if (!PushAccess.HasValue) { sessionService.GitHubClient.Repository.Get(RepositoryOwner, RepositoryName) .ToBackground(x => PushAccess = x.Permissions.Push); } using (var stream = filesystemService.CreateTempFile(out filepath, Name)) { if (MarkdownExtensions.Any(Path.EndsWith)) { var renderedContent = await sessionService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContentFileRendered(Path, Branch); using (var stringWriter = new StreamWriter(stream)) { await stringWriter.WriteAsync(renderedContent); } } else { if (string.IsNullOrEmpty(GitUrl) || string.IsNullOrEmpty(HtmlUrl)) { var req = sessionService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContentFile(Path, Branch); var data = (await sessionService.Client.ExecuteAsync(req)).Data; GitUrl = data.GitUrl; HtmlUrl = data.HtmlUrl; } var mime = await sessionService.Client.DownloadRawResource2(GitUrl, stream) ?? string.Empty; isBinary = !(mime ?? string.Empty).Contains("charset"); } } // We can force a binary representation if it was passed during init. In which case we don't care to figure out via the mime. var fileUri = new Uri(filepath); SourceItem = new FileSourceItemViewModel(fileUri, ForceBinary || isBinary); }); }