private async void StartPage_Loaded(object sender, RoutedEventArgs e)
{
try
{
var model = new List <ExamplesModel>();
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("anndotnet"));
//var cnt = await client.Repository.Content.GetAllContents("bhrnjica", "anndotnet", "Examples");
var cnt = await client.Repository.Content.GetAllContentsByRef("bhrnjica", "anndotnet", "Examples", m_defaultBranch);
//
foreach (var f in cnt.Where(x => x.Name.EndsWith("zip")))
{
var em = new ExamplesModel();
em.Name = f.Name;
em.Path = f.Path;
var pathReadm = f.Path.Replace(f.Name, System.IO.Path.GetFileNameWithoutExtension(f.Name) + ".txt");
var fileWithContent = await client.Repository.Content.GetAllContentsByRef("bhrnjica", "anndotnet", pathReadm, m_defaultBranch);
em.Description = fileWithContent.FirstOrDefault()?.Content;
model.Add(em);
}
listView.ItemsSource = model;
}
catch (Exception ex)
{
if (ReportException != null)
{
ReportException(ex);
}
}
}
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());
}
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());
}
/*private void ShowGeneral(object sender, RoutedEventArgs e)
* {
* HideAllPages();
* GeneralBtn.IsChecked = true;
* generalWindow.Visibility = Visibility.Visible;
* }
*
* private void AppearanceBtn_Click(object sender, RoutedEventArgs e)
* {
* HideAllPages();
* AppearanceBtn.IsChecked = true;
* appearanceWindow.Visibility = Visibility.Visible;
* }
*
* private void ShowTiles(object sender, RoutedEventArgs e)
* {
* HideAllPages();
* TilesBtn.IsChecked = true;
* tilesWindow.Visibility = Visibility.Visible;
* }
*
* private void ShowDirectoryPortals(object sender, RoutedEventArgs e)
* {
* HideAllPages();
* DirectoryPortalBtn.IsChecked = true;
* }
*
* private void ShowFloatingImages(object sender, RoutedEventArgs e)
* {
* HideAllPages();
* FloatingImageBtn.IsChecked = true;
* }
*
* private void ShowNotes(object sender, RoutedEventArgs e)
* {
* HideAllPages();
* NotesBtn.IsChecked = true;
* }
*
* private void HideAllPages()
* {
* GeneralBtn.IsChecked = false;
* AppearanceBtn.IsChecked = false;
* TilesBtn.IsChecked = false;
* DirectoryPortalBtn.IsChecked = false;
* FloatingImageBtn.IsChecked = false;
* NotesBtn.IsChecked = false;
* generalWindow.Visibility = Visibility.Collapsed;
* appearanceWindow.Visibility = Visibility.Collapsed;
* tilesWindow.Visibility = Visibility.Collapsed;
* }*/
private async void ShowUpdates(object sender, RoutedEventArgs e)
{
try
{
//Check updates
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("tiels-updates-check"));
var releases = await client.Repository.Release.GetAll("DcZipPL", "Tiels");
var latest = releases[0];
if (latest.TagName == App.Version)
{
ErrorHandler.Info("No updates found.");
}
else
{
UpdatesBtn.FontWeight = FontWeights.Bold;
UpdatesBtn.Foreground = Brushes.ForestGreen;
Process.Start("https://github.com/DcZipPL/Tiels/releases");
}
Console.WriteLine(
"[Debug] The latest release is tagged at {0} and is named {1}",
latest.TagName,
latest.Name);
}
catch (Exception ex)
{
UpdatesBtn.Foreground = Brushes.DarkRed;
}
}
public static void CheckForUpdates(bool showErrors)
{
try
{
var githubClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("SwitchLayoutEditor"));
var ver = githubClient.Repository.Release.GetAll("FuryBaguette", "SwitchLayoutEditor").GetAwaiter().GetResult();
if (ver.Count > AppRelease)
{
if (MessageBox.Show($"A new version has been found: {ver[0].Name}\r\n{ver[0].Body}\r\nOpen the github page ?", "", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
System.Diagnostics.Process.Start("https://github.com/FuryBaguette/SwitchLayoutEditor/releases/latest");
}
}
else if (showErrors)
{
MessageBox.Show("You're running the latest version :)");
}
}
catch (Exception ex)
{
if (showErrors)
{
MessageBox.Show("Error while searching for updates:\r\n" + ex.ToString());
}
}
}
private Octokit.GitHubClient GetClient()
{
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue(this.Settings.GitHubAppName));
var basicAuth = new Octokit.Credentials(this.Settings.GitHubUserId, this.Settings.GitHubPassword);
client.Credentials = basicAuth;
return client;
}
public Updater(string header, string user, string repo, string localver)
{
_Client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue(header));
_User = user;
_Repo = repo;
_LocalVersion = localver;
}
public static void Main(String[] args)
{
var cre = new NetworkCredential()
{
UserName = "******",
Password = "******"
};
var repo = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("lookuper"));
var c = repo.Repository.Commits.GetAll("lookuper", "codeheat", new Octokit.CommitRequest()).Result;
//var git = new GitRepository("https://github.com/lookuper/CodeHeat", "codeheat", copyIfNotLocal:true, branch:"master", credentials:cre);
//git.GetLatestChanges();
//git.Dispose();
//git = new GitRepository("codeheat");
////var commits = git.GetCommits();
//var a = new HeatAnalyzer(git);
//var res = a.GetUsers();
//var commits = a.GetUserCommits(res.First().Name);
////a.CompareCommit(commits.First());
////a.GetModifiedFilesForCommit(commits[0]);
//var p2 = a.GetMostUsedFilesFirst();
//git.DeleteRepository();
}
public static async void CheckUpdate()
{
try
{
Octokit.GitHubClient client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("Coolapk-UWP"));
var release = await client.Repository.Release.GetLatest("Tangent-90", "Coolapk-UWP");
var ver = release.TagName.Replace("v", string.Empty).Split('.');
if (ushort.Parse(ver[0]) > Package.Current.Id.Version.Major ||
(ushort.Parse(ver[0]) == Package.Current.Id.Version.Major && ushort.Parse(ver[1]) > Package.Current.Id.Version.Minor) ||
(ushort.Parse(ver[0]) == Package.Current.Id.Version.Major && ushort.Parse(ver[1]) == Package.Current.Id.Version.Minor && ushort.Parse(ver[2]) > Package.Current.Id.Version.Build))
{
GetUpdateContentDialog dialog = new GetUpdateContentDialog(release.HtmlUrl, release.Body)
{
RequestedTheme = Settings.GetBoolen("IsDarkMode") ? ElementTheme.Dark : ElementTheme.Light
};
await dialog.ShowAsync();
}
else
{
Tools.rootPage?.ShowMessage("当前无可用更新。");
}
}
catch (HttpRequestException ex) { Tools.rootPage?.ShowHttpExceptionMessage(ex); }
}
public async Task LoginWithToken(string clientId, string clientSecret, string code, string redirect, string requestDomain, string apiDomain)
{
var oauthRequest = new Octokit.OauthTokenRequest(clientId, clientSecret, code)
{
RedirectUri = new Uri(redirect)
};
var client = new Octokit.GitHubClient(OctokitClientFactory.UserAgent);
var token = await client.Oauth.CreateAccessToken(oauthRequest);
var credentials = new Octokit.Credentials(token.AccessToken);
client = OctokitClientFactory.Create(new Uri(apiDomain), credentials);
var user = await client.User.Current();
var account = await _accountsService.Get(apiDomain, user.Login);
account = account ?? new Account {
Username = user.Login
};
account.OAuth = token.AccessToken;
account.AvatarUrl = user.AvatarUrl;
account.Domain = apiDomain;
account.WebDomain = requestDomain;
await _accountsService.Save(account);
await _applicationService.LoginAccount(account);
}
public static string GetLokiDownloadUrl()
{
try
{
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("Octokit"));
var apiResult = client.Repository.Release.GetAll("Neo23x0", "Loki").Result;
if (apiResult.Count > 0)
{
var releaseObj = apiResult.First();
if (releaseObj.Assets.Count > 0)
{
return(releaseObj.Assets[0].BrowserDownloadUrl);
}
}
}
catch (Exception ex)
{
Program.ExitOnError(string.Format("[!] Failed to query GitHub: {0}", ex.ToString()));
}
return(null);
}
private async void CheckForUpdate()
{
// Only check if we haven't checked before
if (latest_release != null)
{
return;
}
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("TurtleHub"));
// Check to see if there is an update for TurtleHub
Logger.LogMessageWithData("Checking for new TurtleHub release");
var latest = await client.Repository.Release.GetLatest("dail8859", "TurtleHub");
Logger.LogMessage("\tFound " + latest.TagName);
var thatVersion = Version.Parse(latest.TagName.Substring(1)); // remove the v from e.g. v0.1.1
var thisVersion = typeof(Plugin).Assembly.GetName().Version;
Logger.LogMessage("\tThis " + thisVersion.ToString());
Logger.LogMessage("\tThat " + thatVersion.ToString());
if (thatVersion > thisVersion)
{
updateNotifyIcon.BalloonTipText = string.Format(updateNotifyIcon.BalloonTipText, latest.TagName);
updateNotifyIcon.Visible = true;
updateNotifyIcon.ShowBalloonTip(15 * 1000);
}
latest_release = latest;
}
Octokit.GitHubClient CreateGitHubClient(string gitHubToken)
{
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("code-central"));
var basicAuth = new Octokit.Credentials(gitHubToken);
client.Credentials = basicAuth;
return(client);
}
/// <summary>
/// A generic update checker for github projects
/// The tag text is used as version field from github releases, the description text should contain an installer link pointed at raw.githubusercontent.com
/// </summary>
/// <returns></returns>
private static async Task UpdaterThreadAsync()
{
retry:
Octokit.GitHubClient client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue(product_name));
IReadOnlyList <Octokit.Release> rlsAll = await client.Repository.Release.GetAll(github_user, product_name);
if (rlsAll != null && rlsAll.Count > 0)
{
Octokit.Release latest = rlsAll.OrderBy(r => r.CreatedAt).Last();
Version latest_version = null;
if (Version.TryParse(latest.TagName, out latest_version))
{
if (Assembly.GetExecutingAssembly().GetName().Version < latest_version)
{
if (MessageBox.Show($"A New Version {latest.TagName} of {product_name} has been released, do you wish to update?", "New Version Available!", MessageBoxButtons.YesNo, MessageBoxIcon.Information) == DialogResult.Yes)
{
string[] body = latest.Body.Split(new[] { '"' }, StringSplitOptions.RemoveEmptyEntries);
string installerUrl = string.Empty;
foreach (var tmp in body)
{
if (tmp.Contains("raw.githubusercontent.com"))
{
installerUrl = tmp;
break;
}
}
if (installerUrl != string.Empty)
{
if (File.Exists("update.msi"))
{
File.Delete("update.msi");
}
using (var _client = new WebClient())
{
_client.DownloadFile(installerUrl, "update.msi");
}
Process.Start("update.msi");
Application.Exit();
Environment.Exit(Environment.ExitCode);
}
else
{
Process.Start($"https://github.com/{github_user}/{product_name}/releases");
}
}
}
}
}
await Task.Delay(updatecheck_interval_mins * 60000);
goto retry;
}
private async System.Threading.Tasks.Task <object> AktualizacjaDanychAsync()
{
var commity = @params.Session.GetGitHubExtension().Commity;
try
{
var github = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("sonetaGitHubConnector"));
var branches = await github.Repository.Branch.GetAll(@params.pWlasciciel, @params.pNazwa);
//var commits = await github.Repository.Commit.GetAll("Pavlino", "enovaGitHubAnalyser");
List <Octokit.GitHubCommit> commits = new List <Octokit.GitHubCommit>();
foreach (var branch in branches)
{
var commitRequest = new Octokit.CommitRequest();
commitRequest.Sha = branch.Name;
var branchCommits = await github.Repository.Commit.GetAll(@params.pWlasciciel, @params.pNazwa, commitRequest);
commits.AddRange(branchCommits);
}
if (commits.Count > 0)
{
using (var t = @params.Session.Logout(true))
{
List <string> shas = new List <string>();
foreach (Octokit.GitHubCommit c in commits)
{
if (!shas.Contains(c.Sha))
{
shas.Add(c.Sha);
if (!commity.CommitExists(c.Sha))
{
Commit commit = new Commit
{
SHA = c.Sha,
Autor = c.Commit.Author.Name,
Data = c.Commit.Author.Date.UtcDateTime
};
@params.Session.AddRow(commit);
}
}
}
commity.RemoveInvalidCommits(shas);
t.Commit();
}
}
return("Operacja zakończona pomyślnie");
}
catch (Exception e)
{
return("Błąd poczdas operacji: " + e.Message);
}
}
public CommitAnalyzer(Subscription subscription, Octokit.GitHubClient installationClient, Dictionary <string, Contributor> contributors = null, Dictionary <string, string> fileCanonicalMapper = null, SophiaDbContext dbContext = null)
{
_fileCanonicalMapper = fileCanonicalMapper ?? new Dictionary <string, string>();
_contributors = contributors ?? new Dictionary <string, Contributor>();
_dbContext = dbContext;
_subscription = subscription;
_installationClient = installationClient;
}
/// <summary>
/// Prompts the user to open the <see cref="GitHubLoginPrompt"/> explaining the API rate limit
/// </summary>
/// <param name="client">The <see cref="Octokit.GitHubClient"/> to use</param>
/// <returns><see langword="true"/> if the <see cref="GitHubLoginPrompt"/> ran and returned a <see cref="DialogResult.OK"/>, <see langword="false"/> otherwise</returns>
public static bool RateLimitPrompt(Octokit.GitHubClient client)
{
if (MessageBox.Show("You seem to have hit the rate limit of 60 requests per hour of the GitHub API for anonymous requests. Would you like to enter credentials to bypass this?", "Rate limited", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return(false);
}
using (var D = new GitHubLoginPrompt(client))
return(D.ShowDialog() == DialogResult.OK);
}
private static Octokit.Release getLatestRelease()
{
var gitHubClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("Libation"));
// https://octokitnet.readthedocs.io/en/latest/releases/
var releases = gitHubClient.Repository.Release.GetAll("rmcrackan", "Libation").GetAwaiter().GetResult();
var latest = releases.First(r => !r.Draft && !r.Prerelease);
return(latest);
}
//public async void UpdateAmazonInfo()
//{
// storeItems.Clear();
// await storeItems.AddSearchResult(AppResources.ProfileDeveloperAccountsAmazonKindle, Nager.AmazonProductAdvertising.Model.AmazonSearchIndex.Books);
//}
public async void UpdateGithubInfo()
{
try
{
var github = new Octokit.GitHubClient(new Octokit.ProductHeaderValue(nameof(WordbookImpressApp)));
var user = await github.User.Get(AppResources.ProfileDeveloperAccountsGithub);
Model.GithubUser = new GithubUserViewModel(user);
}
catch { }
}
public bool Load()
{
Account = Account.Load();
if (Account == null)
return false;
var connection = new Octokit.Connection(new Octokit.ProductHeaderValue("RepoStumble"));
connection.Credentials = new Octokit.Credentials(Account.OAuth);
Client = new Octokit.GitHubClient(connection);
LoadLikesFromStars();
return true;
}
public static async Task <bool> IsNewestVersion()
{
//All github releases have "v" prefix
var currentVersion = "v" + About.AppVersion.ToString();
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("NLP-Japanese-Dictionary"));
var releases = await client.Repository.Release.GetAll("AnkiUniversal", "NLP-Japanese-Dictionary");
var latest = releases[0];
return(currentVersion.Equals(latest.TagName, StringComparison.OrdinalIgnoreCase));
}
public static async Task CheckForUpdates()
{
var githubClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("OdysseyEditor"));
var ver = await githubClient.Repository.Release.GetAll("exelix11", "OdysseyEditor");
if (ver.Count > ReleaseID)
{
if (MessageBox.Show($"There is a new version of the editor, do you want to open the github page ?\r\n\r\nDetails:\r\n{ver[0].Body}", "", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
System.Diagnostics.Process.Start("https://github.com/exelix11/OdysseyEditor/releases");
}
}
}
public static async Task <GithubReleaseVersion> GetRemoteVersion(string ownerName, string projectName)
{
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("my-cool-app"));
var releases = await client.Repository.Release.GetAll(owner : ownerName, name : projectName);
var latest = releases[0];
return(new GithubReleaseVersion()
{
Version = latest.TagName,
LatestVersionUrl = latest.HtmlUrl
});
}
/// <summary>
/// Gets the download path of the latest release in GitHub.
/// </summary>
/// <returns>The download path of the latest release in GitHub.</returns>
private async Task <string> GetLatestReleaseDownloadPathInGitHubAsync()
{
string downloadUrl = string.Empty;
Octokit.GitHubClient client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("searcher"));
Octokit.Release latestRelease = await client.Repository.Release.GetLatest("wizden", "searcher");
if (latestRelease != null && latestRelease.Assets != null && latestRelease.Assets.Count > 0)
{
downloadUrl = latestRelease.Assets[0].BrowserDownloadUrl;
}
return(downloadUrl);
}
public static async Task <GitHubRelease> CheckForUpdates(string owner, string name)
{
try
{
var githubClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("EditorCore"));
var ver = await githubClient.Repository.Release.GetAll(owner, name);
return(new GitHubRelease(ver[ver.Count - 1], ver.Count - 1));
}
catch
{
return(null);
}
}
static async Task Main(string[] args)
{
//Follow these steps to create a GitHub Access Token https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/#creating-a-token
//Select the following permissions for your GitHub Access Token:
// - repo:status
// - public_repo
var key = GetEnvVariable("GitHubKey",
"You must store you GitHub key in the 'GitHubKey' environment variable",
"");
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("IssueQueryDemo"))
{
Credentials = new Octokit.Credentials(key)
};
// Next: Run the issue query.
var issueAndPRQuery = new GraphQLRequest
{
Query = Queries.IssueQuery
};
issueAndPRQuery.Variables["repo_name"] = "docs";
var postBody = issueAndPRQuery.ToJsonText();
var response = await client.Connection.Post <string>(new Uri("https://api.github.com/graphql"),
postBody, "application/json", "application/json");
JObject results = JObject.Parse(response.HttpResponse.Body.ToString());
Console.WriteLine(results);
// Find PRs:
issueAndPRQuery.Query = Queries.PullRequestQuery;
issueAndPRQuery.Variables["repo_name"] = "docs";
postBody = issueAndPRQuery.ToJsonText();
response = await client.Connection.Post <string>(new Uri("https://api.github.com/graphql"),
postBody, "application/json", "application/json");
results = JObject.Parse(response.HttpResponse.Body.ToString());
Console.WriteLine(results);
// TODO as a lab:
// 1. Find the latest 50 Open issues in the dotnet/docs repo.
// 2. Find the latest 50 in dotnet-api-docs
// 3. Do the same for PRs in: dotnet/docs, dotnet/dotnet-api-docs, dotnet/samples
Console.ReadLine();
}
public bool Load()
{
Account = Account.Load();
if (Account == null)
{
return(false);
}
var connection = new Octokit.Connection(new Octokit.ProductHeaderValue("RepoStumble"));
connection.Credentials = new Octokit.Credentials(Account.OAuth);
Client = new Octokit.GitHubClient(connection);
LoadLikesFromStars();
return(true);
}
private void InitializeGitClient()
{
try
{
if (gitClient == null)
{
gitClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("Panacea"));
uDebugLogAdd("gitClient was null, initialized gitClient");
}
}
catch (Exception ex)
{
LogException(ex);
}
}
private static void CheckLatestRelease()
{
if (ToolkitSettings.CheckForUpdates)
{
try
{
Octokit.GitHubClient client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("ToolkitUpdater", "1"));
GetLatest(client).Wait();
}
catch (Exception)
{
MessageBox.Show(Language.GetString("$FAILED_UPDATE_CHECK"), "Toolkit", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
private async void Window_Initialized(object sender, EventArgs e)
{
var gitHubClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("TexPup"));
try
{
Octokit.Release release = await gitHubClient.Repository.Release.GetLatest("JKAnderson", "TexPup");
if (SemVersion.Parse(release.TagName) > System.Windows.Forms.Application.ProductVersion)
{
UpdateHyperlink.NavigateUri = new Uri(release.HtmlUrl);
UpdateStatusBarItem.Visibility = Visibility.Visible;
}
}
catch { }
}
public static async Task RunAsync(
DeleteBranchMessage deleteBranchMessage,
Installation installation,
IInstallationTokenProvider installationTokenProvider,
ILogger logger,
ExecutionContext context)
{
if (installation == null)
{
logger.LogError("No installation found for {InstallationId}", deleteBranchMessage.InstallationId);
throw new Exception($"No installation found for InstallationId: {deleteBranchMessage.InstallationId}");
}
var installationToken = await installationTokenProvider.GenerateAsync(
new InstallationTokenParameters
{
AccessTokensUrl = string.Format(KnownGitHubs.AccessTokensUrlFormat, installation.InstallationId),
AppId = KnownGitHubs.AppId,
},
KnownEnvironmentVariables.APP_PRIVATE_KEY);
logger.LogInformation("DeleteBranchFunction: Deleting imgbot branch for {Owner}/{RepoName}", installation.Owner, installation.RepoName);
var inMemoryCredentialStore = new InMemoryCredentialStore(new Octokit.Credentials(KnownGitHubs.Username, installationToken.Token));
var githubClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("ImgBot"), inMemoryCredentialStore);
var imgbotRefName = $"heads/{KnownGitHubs.BranchName}";
Octokit.Reference imgbotBranchRef = null;
try
{
imgbotBranchRef = await githubClient.Git.Reference.Get(installation.Owner, installation.RepoName, imgbotRefName);
}
catch
{
}
if (imgbotBranchRef == null)
{
logger.LogInformation("DeleteBranchFunction: No imgbot branch found for {Owner}/{RepoName}", installation.Owner, installation.RepoName);
return;
}
await githubClient.Git.Reference.Delete(installation.Owner, installation.RepoName, imgbotRefName);
logger.LogInformation("DeleteBranchFunction: Successfully deleted imgbot branch for {Owner}/{RepoName}", installation.Owner, installation.RepoName);
}
private async void FormMain_Load(object sender, EventArgs e)
{
Text = "U3M " + Application.ProductVersion;
enableControls(true);
Location = settings.WindowLocation;
if (settings.WindowSize.Width >= MinimumSize.Width && settings.WindowSize.Height >= MinimumSize.Height)
{
Size = settings.WindowSize;
}
if (settings.WindowMaximized)
{
WindowState = FormWindowState.Maximized;
}
txtGameDir.Text = settings.GameDir;
cbxData1.Checked = settings.Data1Checked;
cbxData2.Checked = settings.Data2Checked;
cbxData3.Checked = settings.Data3Checked;
cbxData4.Checked = settings.Data4Checked;
cbxData5.Checked = settings.Data5Checked;
cbxDLC1.Checked = settings.DLC1Checked;
cbxDLC2.Checked = settings.DLC2Checked;
Octokit.GitHubClient gitHubClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("U3M"));
try
{
Octokit.Release release = await gitHubClient.Repository.Release.GetLatest("JKAnderson", "U3M");
if (SemVersion.Parse(release.TagName) > Application.ProductVersion)
{
lblUpdate.Visible = false;
LinkLabel.Link link = new LinkLabel.Link();
link.LinkData = UPDATE_LINK;
llbUpdate.Links.Add(link);
llbUpdate.Visible = true;
}
else
{
lblUpdate.Text = "App up to date";
}
}
catch (Exception ex) when(ex is HttpRequestException || ex is Octokit.ApiException || ex is ArgumentException)
{
lblUpdate.Text = "Update status unknown";
}
}
public async static void Updater()
{
/* Credits to WildGoat07 : https://github.com/WildGoat07 */
var github = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("SimpleMhwModManager"));
var lastRelease = await github.Repository.Release.GetLatest(234864718);
var current = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
if (new Version(lastRelease.TagName) > current)
{
var result = MessageBox.Show("A new version is available, do you want to download it now ?", "SMMM", MessageBoxButton.YesNo, MessageBoxImage.Information);
if (result == MessageBoxResult.Yes)
{
Process.Start("https://github.com/oxypomme/SimpleMhwModManager/releases/latest");
}
}
}
public void RunUpdateProcess(Version currentAppVersion)
{
UpdateStatus("Checking for update...");
var github = new Octokit.GitHubClient(new Octokit.ProductHeaderValue(_projectname));
var release = github.Repository.Release.GetAll(_username, _projectname).Result.FirstOrDefault();
var verstr = release.TagName;
if (verstr.StartsWith("v"))
{
verstr = verstr.Remove(0, 1);
}
if (verstr.Count(c => c == '.') < 3)
{
verstr += ".0";
}
var latestversion = new Version(verstr);
if (latestversion > currentAppVersion)
{
var message = string.Format("A new version {0} is available!\rDo you want to download and install?", release.TagName);
var result = MessageBox.Show(message, "Update Confirmation", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
if (result != DialogResult.Yes)
{
UpdateStatus("App update is canceled by user!");
return;
}
}
else
{
UpdateStatus("Already using the latest version!");
MessageBox.Show("You are already using the latest version!", "Update Check",
MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
_installerFilename = Path.Combine(Path.GetTempPath(), release.Assets.FirstOrDefault().Name);
UpdateStatus(string.Format("Downloading... 0%, Total {0} bytes to {1}",
release.Assets.FirstOrDefault().Size, Path.GetFileName(_installerFilename)));
using (var webclient = new WebClient())
{
webclient.DownloadProgressChanged += WebClient_DownloadProgressChanged;
webclient.DownloadFileCompleted += WebClient_DownloadFileCompleted;
webclient.DownloadFileAsync(new Uri(release.Assets.FirstOrDefault().BrowserDownloadUrl), _installerFilename);
}
}
public void ProcessRequest(HttpContext context)
{
string path = System.Web.HttpContext.Current.Server.MapPath("/");
appPath = path + "app\\apps\\";
appPathDev = path + "app\\apps\\dev\\";
appPathPub = path + "app\\apps\\pub\\";
try
{
context.Response.ContentType = "text/plain";
string appName = context.Request.QueryString.Get("appid");
string mode = context.Request.QueryString.Get("mode"); //mode 1 dev mode 2 publish
if (appName == null)
{
context.Response.StatusCode = 404;
context.Response.Write("appid not found");
context.Response.End();
return;
}
if (mode == null)
{
context.Response.StatusCode = 404;
context.Response.Write("mode not found");
context.Response.End();
return;
}
if (mode == "1")
{
appPath = appPathDev;
}
else if (mode == "2")
{
appPath = appPathPub;
}
var credentials = new Octokit.Credentials("Xapps00", "xapps00xapps00");
var connection = new Octokit.Connection(new Octokit.ProductHeaderValue("XApps"))
{
Credentials = credentials
};
var octokitClient = new Octokit.GitHubClient(connection);
var branch = octokitClient.Repository.GetBranch("xapps00", appName, "master").Result;
var branchTree = octokitClient.GitDatabase.Tree.Get("xapps00", appName, branch.Commit.Sha).Result;
if (Directory.Exists(appPath + appName))
{
}
else
{
Directory.CreateDirectory(appPath + appName);
}
foreach (var treeItem in branchTree.Tree)
{
if (treeItem.Type.Equals(Octokit.TreeType.Tree))
{
if (!Directory.Exists(appPath + "/" + appName + "/" + treeItem.Path))
{
Directory.CreateDirectory(appPath + "/" + appName + "/" + treeItem.Path);
}
var subBranch = octokitClient.GitDatabase.Tree.Get("xapps00", appName, treeItem.Sha).Result;
foreach (var item in subBranch.Tree)
{
if (item.Type.Equals(Octokit.TreeType.Blob))
{
var tempBlob = octokitClient.GitDatabase.Blob.Get("xapps00", appName, item.Sha).Result;
var tempContents = tempBlob.Content;
byte[] data = Convert.FromBase64String(tempContents);
string decodedString = Encoding.UTF8.GetString(data);
if (!File.Exists(appPath + "/" + appName + "/" + treeItem.Path))
{
//File.Create(appPath + "/" + appName + "/" + treeItem.Path+"/"+item.Path);
StreamWriter file =
new StreamWriter(appPath + "/" + appName + "/" + treeItem.Path + "/" + item.Path);
file.Write(decodedString);
file.Close();
}
else
{
//TO-DO: check the hash values from DB and retrive
}
}
}
}
}
context.Response.StatusCode = 200;
context.Response.Write("{appName:'" + appName + "', appPath:'" + appPath + "'");
}
catch (Exception e)
{
context.Response.StatusCode = 404;//send error code
}
}
private Game(string path, string token, string owner, string repo, string hash)
{
this.path = path;
this.client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("GitGameServer")) { Credentials = new Octokit.Credentials(token) };
this.owner = owner;
this.repository = repo;
}
public static async Task<Octokit.Release> getLatestVersion()
{
var github = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("AdventureWindows"));
var releases = await github.Release.GetAll("Wavesonics", "AdventureWindows");
return releases[0];
}
/// <summary>
/// Async latest version checker, gives a popup if a different version is detected
/// </summary>
/// <returns></returns>
public async Task LatestPass4WinRelease()
{
var client = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("Pass4Win"));
var _releaseClient = client.Release;
var releases = await _releaseClient.GetAll("mbos", "Pass4Win");
// online version
string newversion = releases[0].TagName.Remove(0, 8);
// if diff warn and redirect
if (cfg["version"] != newversion)
{
DialogResult result = MessageBox.Show(Strings.Info_new_version, Strings.Info_new_version_caption, MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
if (result == DialogResult.OK)
{
// start browser
System.Diagnostics.Process.Start("https://github.com/mbos/Pass4Win/releases");
}
}
}
