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);
}
