public ReleasesViewModel(ISessionService applicationService) { Title = "Releases"; Items = InternalItems.CreateDerivedCollection(CreateItemViewModel, x => !x.Draft); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => InternalItems.Reset(await applicationService.GitHubClient.Release.GetAll(RepositoryOwner, RepositoryName))); }
/// <summary> /// Creates a new Detour. /// </summary> /// <param name="target"> /// The original function to detour. (This delegate should already be registered via /// Magic.RegisterDelegate) /// </param> /// <param name="newTarget">The new function to be called. (This delegate should NOT be registered!)</param> /// <param name="name">The name of the detour.</param> /// <returns> /// A <see cref="Detour" /> object containing the required methods to apply, remove, and call the original /// function. /// </returns> public Detour Create(Delegate target, Delegate newTarget, string name) { if (target == null) { throw new ArgumentNullException(nameof(target)); } if (newTarget == null) { throw new ArgumentNullException(nameof(newTarget)); } if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } if (!AttributesHelper.HasUfpAttribute(target)) { throw new Exception( "The target delegate does not have the proper UnmanagedFunctionPointer attribute!"); } if (!AttributesHelper.HasUfpAttribute(newTarget)) { throw new Exception( "The new target delegate does not have the proper UnmanagedFunctionPointer attribute!"); } if (InternalItems.ContainsKey(name)) { throw new ArgumentException($"The {name} detour already exists!", nameof(name)); } InternalItems[name] = new Detour(target, newTarget, name, MemoryPlus); return(InternalItems[name]); }
/// <summary> /// Creates a new Detour. /// </summary> /// <param name="target"> /// The original function to detour. (This delegate should already be registered via /// Magic.RegisterDelegate) /// </param> /// <param name="newTarget">The new function to be called. (This delegate should NOT be registered!)</param> /// <param name="name">The name of the detour.</param> /// <param name="ignoreAntiCheatRules"></param> /// <returns> /// A <see cref="Detour" /> object containing the required methods to apply, remove, and call the original /// function. /// </returns> public Detour Create(Delegate target, Delegate newTarget, string name, bool ignoreAntiCheatRules = false) { if (target == null) { throw new ArgumentNullException(nameof(target)); } if (newTarget == null) { throw new ArgumentNullException(nameof(newTarget)); } if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } if (!target.IsUnmanagedFunctionPointer()) { throw new Exception("The target delegate does not have the proper UnmanagedFunctionPointer attribute!"); } if (!newTarget.IsUnmanagedFunctionPointer()) { throw new Exception( "The new target delegate does not have the proper UnmanagedFunctionPointer attribute!"); } if (InternalItems.ContainsKey(name)) { throw new ArgumentException($"The {name} detour already exists!", nameof(name)); } InternalItems[name] = new Detour(target, newTarget, name, ProcessPlus, ignoreAntiCheatRules); return(InternalItems[name]); }
private async Task UpdateIssue(Issue issue) { var localIssue = InternalItems.FirstOrDefault(x => x.Url == issue.Url); if (localIssue == null) { return; } var index = InternalItems.IndexOf(localIssue); if (index < 0) { return; } var matches = System.Text.RegularExpressions.Regex.Matches(issue.Url.AbsolutePath, "/repos/([^/]+)/([^/]+)/.+"); if (matches.Count != 1 || matches[0].Groups.Count != 3) { return; } InternalItems[index] = await _sessionService.GitHubClient.Issue.Get(matches[0].Groups[1].Value, matches[0].Groups[2].Value, issue.Number); InternalItems.Reset(); }
private async Task <IReadOnlyList <Issue> > RetrieveIssues(int page = 1) { var connection = _sessionService.GitHubClient.Connection; var parameters = new Dictionary <string, string>(); parameters["page"] = page.ToString(); parameters["per_page"] = 50.ToString(); AddRequestParameters(parameters); parameters = parameters.Where(x => x.Value != null).ToDictionary(x => x.Key, x => x.Value); var ret = await connection.Get <IReadOnlyList <Issue> >(RequestUri, parameters, "application/json"); if (ret.HttpResponse.ApiInfo.Links.ContainsKey("next")) { LoadMoreCommand = ReactiveCommand.CreateAsyncTask(async _ => { InternalItems.AddRange(await RetrieveIssues(page + 1)); }); } else { LoadMoreCommand = null; } return(ret.Body); }
public MyIssuesViewModel(ISessionService sessionService) : base(sessionService) { _sessionService = sessionService; Title = "My Issues"; Filter = MyIssuesFilterModel.CreateOpenFilter(); _selectedFilter = this.WhenAnyValue(x => x.Filter) .Select(x => { if (x == null || _openFilter.Equals(x)) { return(0); } return(_closedFilter.Equals(x) ? 1 : -1); }) .ToProperty(this, x => x.SelectedFilter); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(filter => { InternalItems.Clear(); LoadCommand.ExecuteIfCan(); CustomFilterEnabled = !(filter == _closedFilter || filter == _openFilter); }); GoToFilterCommand = ReactiveCommand.Create(); GoToFilterCommand.Subscribe(_ => { var vm = this.CreateViewModel <MyIssuesFilterViewModel>(); vm.Init(Filter); vm.SaveCommand.Subscribe(filter => Filter = filter); NavigateTo(vm); }); }
public LanguagesViewModel() { Title = "Languages"; DismissCommand = ReactiveCommand.Create(); DismissCommand.Subscribe(_ => this.Dismiss()); Items = InternalItems.CreateDerivedCollection( x => new LanguageItemViewModel(x.Name, x.Slug), filter: x => x.Name.StartsWith(SearchKeyword ?? string.Empty, StringComparison.OrdinalIgnoreCase), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); Items .Changed.Select(_ => Unit.Default) .Merge(this.WhenAnyValue(x => x.SelectedLanguage).Select(_ => Unit.Default)) .Select(_ => SelectedLanguage) .Where(x => x != null) .Subscribe(x => { foreach (var l in Items) { l.Selected = l.Slug == x.Slug; } }); this.WhenAnyValue(x => x.SelectedLanguage) .IsNotNull() .Subscribe(_ => Dismiss()); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var languageRepository = new LanguageRepository(); var langs = await languageRepository.GetLanguages(); langs.Insert(0, LanguageRepository.DefaultLanguage); InternalItems.Reset(langs); }); }
public PullRequestsViewModel(ISessionService sessionService) { _sessionService = sessionService; Title = "Pull Requests"; Items = InternalItems.CreateDerivedCollection(x => { var vm = new PullRequestItemViewModel(x); vm.GoToCommand.Subscribe(_ => { var prViewModel = this.CreateViewModel <PullRequestViewModel>(); prViewModel.Init(RepositoryOwner, RepositoryName, x.Number, x); NavigateTo(prViewModel); prViewModel.WhenAnyValue(y => y.Issue.State) .DistinctUntilChanged() .Skip(1) .Subscribe(y => LoadCommand.ExecuteIfCan()); }); return(vm); }, filter: x => x.Title.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { InternalItems.Reset(await RetrievePullRequests()); }); this.WhenAnyValue(x => x.SelectedFilter).Skip(1).Subscribe(_ => { InternalItems.Clear(); LoadCommand.ExecuteIfCan(); }); }
public UserExploreViewModel(ISessionService applicationService) { Title = "Explore Users"; Items = InternalItems.CreateDerivedCollection(x => new UserItemViewModel(x.Login, x.AvatarUrl, false, () => { var vm = this.CreateViewModel <UserViewModel>(); vm.Init(x.Login, x); NavigateTo(vm); })); var canSearch = this.WhenAnyValue(x => x.SearchKeyword).Select(x => !string.IsNullOrEmpty(x)); SearchCommand = ReactiveCommand.CreateAsyncTask(canSearch, async t => { try { InternalItems.Clear(); var request = new SearchUsersRequest(SearchKeyword); var response = await applicationService.GitHubClient.Search.SearchUsers(request); InternalItems.Reset(response.Items); } catch (Exception e) { var msg = string.Format("Unable to search for {0}. Please try again.", SearchKeyword.Humanize()); throw new Exception(msg, e); } }); }
public IssuesViewModel(ISessionService sessionService) : base(sessionService) { _sessionService = sessionService; Filter = new IssuesFilterModel(); Title = "Issues"; GoToNewIssueCommand = ReactiveCommand.Create(); GoToNewIssueCommand.Subscribe(_ => { var vm = this.CreateViewModel <IssueAddViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; vm.SaveCommand.Subscribe(x => LoadCommand.ExecuteIfCan()); NavigateTo(vm); }); this.WhenAnyValue(x => x.Filter).Skip(1).Subscribe(filter => { InternalItems.Clear(); LoadCommand.ExecuteIfCan(); //CustomFilterEnabled = !(filter == _closedFilter || filter == _openFilter); }); GoToFilterCommand = ReactiveCommand.Create(); GoToFilterCommand.Subscribe(_ => { var vm = this.CreateViewModel <RepositoryIssuesFilterViewModel>(); vm.Init(RepositoryOwner, RepositoryName, Filter); vm.SaveCommand.Subscribe(filter => { Filter = filter; FilterSelection = IssueFilterSelection.Custom; }); NavigateTo(vm); }); }
public RepositoryExploreViewModel(ISessionService applicationService) { ShowRepositoryDescription = applicationService.Account.ShowRepositoryDescriptionInList; Title = "Explore Repositories"; var gotoRepository = new Action <RepositoryItemViewModel>(x => { var vm = this.CreateViewModel <RepositoryViewModel>(); vm.Init(x.Owner, x.Name, x.Repository); NavigateTo(vm); }); Items = InternalItems.CreateDerivedCollection(x => new RepositoryItemViewModel(x, true, gotoRepository)); var canSearch = this.WhenAnyValue(x => x.SearchKeyword).Select(x => !string.IsNullOrEmpty(x)); SearchCommand = ReactiveCommand.CreateAsyncTask(canSearch, async t => { try { InternalItems.Clear(); var request = new SearchRepositoriesRequest(SearchKeyword); var response = await applicationService.GitHubClient.Search.SearchRepo(request); InternalItems.Reset(response.Items); } catch (Exception e) { var msg = string.Format("Unable to search for {0}. Please try again.", SearchKeyword.Humanize()); throw new Exception(msg, e); } }); }
/// <summary> /// Creates a new <see cref="APatch" /> at the specified address. /// </summary> /// <param name="address">The address to begin the patch.</param> /// <param name="patchWith">The bytes to be written as the patch.</param> /// <param name="name">The name of the patch.</param> /// <returns>A patch object that exposes the required methods to apply and remove the patch.</returns> public APatch Create(IntPtr address, byte[] patchWith, string name) { if (InternalItems.ContainsKey(name)) { return(InternalItems[name]); } InternalItems.Add(name, new APatch(address, patchWith, name, MemoryBase)); return(InternalItems[name]); }
internal IDictionary <string, object> SendableDictionary() { var fields = FieldsShallow; if (InternalItems != null) { fields[ItemName] = InternalItems.Select(item => item.FieldsShallow).ToList(); } return(fields); }
public PublicGistsViewModel(ISessionService sessionService) { _sessionService = sessionService; Title = "Public Gists"; Items = InternalItems.CreateDerivedCollection(x => CreateGistItemViewModel(x)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { InternalItems.Reset(await RetrieveGists()); }); }
protected BaseUsersViewModel(ISessionService sessionService) { SessionService = sessionService; Items = InternalItems.CreateDerivedCollection(x => CreateItemViewModel(x), x => x.Login.StartsWith(SearchKeyword ?? string.Empty, StringComparison.OrdinalIgnoreCase), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { InternalItems.Reset(await RetrieveUsers()); }); }
public CommitBranchesViewModel(ISessionService applicationService) { Title = "Branches"; Items = InternalItems.CreateDerivedCollection( x => CreateItemViewModel(x), filter: x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => InternalItems.Reset(await applicationService.GitHubClient.Repository.GetAllBranches(RepositoryOwner, RepositoryName))); }
protected BaseEventsViewModel(ISessionService sessionService) { SessionService = sessionService; Title = "Events"; Items = InternalItems.CreateDerivedCollection(CreateEventTextBlocks); ReportRepository = true; LoadCommand = ReactiveCommand.CreateAsyncTask(t => InternalItems.SimpleCollectionLoad(CreateRequest(), x => LoadMoreCommand = x == null ? null : ReactiveCommand.CreateAsyncTask(_ => x()))); }
protected void AddItem(ItemT item) { if (item == null) { throw new ArgumentException("Invalid argument"); } if (InternalItems is null) { InternalItems = new List <ItemT>(); } InternalItems.Add((ItemT)item.Clone()); }
protected BaseGistsViewModel(ISessionService sessionService) { SessionService = sessionService; Items = InternalItems .CreateDerivedCollection(x => CreateGistItemViewModel(x)) .CreateDerivedCollection(x => x, filter: x => x.Description.ContainsKeyword(SearchKeyword) || x.Title.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { InternalItems.Reset(await RetrieveGists()); }); }
protected BaseCommitsViewModel(ISessionService sessionService) { SessionService = sessionService; Title = "Commits"; Items = InternalItems.CreateDerivedCollection( x => x, x => x.Description.ContainsKeyword(SearchKeyword) || x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var ret = await RetrieveCommits(); InternalItems.Reset(ret.Select(x => new CommitItemViewModel(x, GoToCommit))); }); }
public OrganizationsViewModel(ISessionService applicationService) { Title = "Organizations"; Items = InternalItems.CreateDerivedCollection( x => new UserItemViewModel(x.Login, x.AvatarUrl, true, () => { var vm = this.CreateViewModel <OrganizationViewModel>(); vm.Init(x.Login, x); NavigateTo(vm); }), filter: x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => InternalItems.Reset(await applicationService.GitHubClient.Organization.GetAll(Username))); }
protected BaseRepositoriesViewModel(ISessionService sessionService) { SessionService = sessionService; ShowRepositoryOwner = true; Title = "Repositories"; Items = InternalItems.CreateDerivedCollection( x => x, filter: x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { var ret = await RetrieveRepositories(); InternalItems.Reset(ret.Select(x => new RepositoryItemViewModel(x, ShowRepositoryOwner, GoToRepository))); }); }
public TeamsViewModel(ISessionService applicationService) { Title = "Teams"; Items = InternalItems.CreateDerivedCollection( x => new TeamItemViewModel(x.Name, () => { var vm = this.CreateViewModel <TeamMembersViewModel>(); vm.Init(x.Id); NavigateTo(vm); }), filter: x => x.Name.ContainsKeyword(SearchKeyword), signalReset: this.WhenAnyValue(x => x.SearchKeyword)); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => InternalItems.Reset(await applicationService.GitHubClient.Organization.Team.GetAll(OrganizationName))); }
private void Render() { Children?.Clear(); if (InternalItems != null && InternalItems.Count() > 0) { GenerateRows(); for (var index = 0; index < InternalItems.Count; index++) { int col = (int)(index % ColumnCount); var row = (int)Math.Floor(index / (float)ColumnCount); var image = CreateImage(InternalItems[index]); Children?.Add(image, col, row); } } }
protected BaseIssuesViewModel(ISessionService sessionService) { _sessionService = sessionService; Items = InternalItems.CreateDerivedCollection( x => CreateItemViewModel(x), filter: IssueFilter, signalReset: this.WhenAnyValue(x => x.SearchKeyword)); Items.Changed.Subscribe(_ => { GroupedIssues = Items.GroupBy(x => x.RepositoryFullName) .Select(x => new IssueGroupViewModel(x.Key, x)).ToList(); }); LoadCommand = ReactiveCommand.CreateAsyncTask(async t => { InternalItems.Reset(await RetrieveIssues()); }); }
/// <inheritdoc /> public Task ExpandAsync() { if (InternalItems == null) { throw new InvalidOperationException("InternalItems is nukk"); } InternalItems.Clear(); var count = VisualTreeHelper.GetChildrenCount(Visual); for (int i = 0; i < count; i++) { InternalItems.Add(new VisualTreeNode { Visual = VisualTreeHelper.GetChild(Visual, i) as Visual, TransformToSource = this.TransformToSource }); } IsExpanded = true; return(Task.CompletedTask); }
public void RemoveItem(string uniqueUUID, bool updateUI) { #region Linq Version //EventSystem.EventMessager.Instance.Raise(new Events.EventBeforeRemoveInventoryItem(item)); //InternalItems.RemoveAll(item => item.Data.UniqueUUID == uniqueUUID); //EventSystem.EventMessager.Instance.Raise(new Events.EventAfterRemoveInventoryItem(item)); #endregion Linq Version #region Foreach Version foreach (ICoreData item in InternalItems.ToArray()) { if (item.BaseData.UniqueUUID == uniqueUUID) { InternalItems.Remove(item); EventSystem.EventMessenger.Instance.Raise(new Events.EventItemWasRemovedFromInventory(InventoryUUID, item, updateUI)); } } #endregion Foreach Version }
public void AddItem(IItem item, bool updateUI) { if (CheckIfExists(item.Data.UniqueUUID) == false) // We dont have the item when false { if (CanAddItem) { EventSystem.EventMessenger.Instance.Raise(new Events.EventBeforeAddInventoryItem(InventoryUUID, item, updateUI)); InternalItems.Add(item); EventSystem.EventMessenger.Instance.Raise(new Events.EventAfterAddInventoryItem(InventoryUUID, item, updateUI)); } else { Debug.LogWarning("The inventory is full with [" + InventoryMaxItems + "] items."); } } else { Debug.LogError("The item with the unique uuid of [" + item.Data.UniqueUUID + "] is already in the inventory."); } }
private async Task <IReadOnlyList <Gist> > RetrieveGists(int page = 1) { var connection = _sessionService.GitHubClient.Connection; var parameters = new Dictionary <string, string>(); parameters["page"] = page.ToString(); var ret = await connection.Get <IReadOnlyList <Gist> >(ApiUrls.PublicGists(), parameters, "application/json"); if (ret.HttpResponse.ApiInfo.Links.ContainsKey("next")) { LoadMoreCommand = ReactiveCommand.CreateAsyncTask(async _ => { InternalItems.AddRange(await RetrieveGists(page + 1)); }); } else { LoadMoreCommand = null; } return(ret.Body); }
private async Task <IReadOnlyList <GitHubCommit> > RetrieveCommits(int page = 1) { var connection = SessionService.GitHubClient.Connection; var parameters = new Dictionary <string, string>(); parameters["page"] = page.ToString(); AddRequestParameters(parameters); var ret = await connection.Get <IReadOnlyList <GitHubCommit> >(RequestUri, parameters, "application/json"); if (ret.HttpResponse.ApiInfo.Links.ContainsKey("next")) { LoadMoreCommand = ReactiveCommand.CreateAsyncTask(async _ => { var loadMore = await RetrieveCommits(page + 1); InternalItems.AddRange(loadMore.Select(x => new CommitItemViewModel(x, GoToCommit))); }); } else { LoadMoreCommand = null; } return(ret.Body); }