Support GitHub Apps about octokit.graphql.net HOT 4 OPEN

    public static class StaticData {
        public static string Repository = "asdf";
        public static string Organization = "asdf";
        public static string AppName = "asdf";
        public static int AppId = 123456;
    }
    
    public static class GitHubClientManager {
        private static TimeSpan jwtExpireTime = TimeSpan.FromMinutes(10);
        private static AccessToken installationToken = null;
        
        private static GitHubClient client = null;
        private static Connection graphQLConnection = null;

        public static async Task<GitHubClient> GetClient() {
            // reuse an existing client when the token it was issues with is still valid
            if (client != null && installationToken != null && DateTimeOffset.UtcNow < installationToken.ExpiresAt) {
                return client;
            }

            // 1. first we authenticate as a app
            // 2. then we need to get the installation id of this app
            // 3. with the installation id we can create an access token
            var jwtToken = CreateJWTToken();
            client = new GitHubClient(new ProductHeaderValue(StaticData.AppName)) {Credentials = new Credentials(jwtToken, AuthenticationType.Bearer)};
            var installation = await client.GitHubApps.GetRepositoryInstallationForCurrent(StaticData.Organization, StaticData.Repository);
            installationToken = await client.GitHubApps.CreateInstallationToken(installation.Id);
            client = new GitHubClient(new ProductHeaderValue(StaticData.AppName)) {Credentials = new Credentials(installationToken.Token, AuthenticationType.Bearer)};
            return client;
        }

        public static async Task<Connection> GetGraphQLConnection() {
            // reuse an existing client when the token it was issues with is still valid
            if (graphQLConnection != null && installationToken != null && DateTimeOffset.UtcNow < installationToken.ExpiresAt) {
                return graphQLConnection;
            }

            // creating a new client will make sure we have an access token 
            await GetClient();
            graphQLConnection = new Connection(new Octokit.GraphQL.ProductHeaderValue(StaticData.AppName), installationToken.Token);
            return graphQLConnection;
        }

        private static string CreateJWTToken() {
            // create a new token
            var generator = new GitHubJwt.GitHubJwtFactory(
                    new GitHubJwt.FilePrivateKeySource("adsf.pem"),
                    new GitHubJwt.GitHubJwtFactoryOptions {
                            AppIntegrationId = StaticData.AppId,
                            ExpirationSeconds = (int)jwtExpireTime.TotalSeconds
                    });
            return generator.CreateEncodedJwtToken();
        }
    }
`

       private static async Task<GitHubClient> GetClient()
       {
           var clientIsOk = client != null;
           var installationTokenIsOk = installationToken != null;
           var tokenIsNotExpired = installationToken != null && DateTimeOffset.UtcNow < installationToken.ExpiresAt;

           if (clientIsOk &&
               installationTokenIsOk &&
               tokenIsNotExpired)
           {
               // reuse an existing client when the token it was issues with is still valid
               return client;
           }

           // A time based JWT token, signed by the GitHub App's private certificate
           var jwtToken = CreateJWTToken();

           // Use the JWT as a Bearer token
           var appClient = new GitHubClient(new ProductHeaderValue(StaticData.AppName))
           {
               Credentials = new Credentials(jwtToken, AuthenticationType.Bearer)
           };

           // Get the current authenticated GitHubApp
           var app = await appClient.GitHubApps.GetCurrent();

           // Get a list of installations for the authenticated GitHubApp
           var installations = await appClient.GitHubApps.GetAllInstallationsForCurrent();

           // Get a specific installation of the authenticated GitHubApp by it's installation Id
           if (installations != null)
           {
               var allInstallationsForCurrent = await appClient.GitHubApps.GetAllInstallationsForCurrent();

               var installation = allInstallationsForCurrent.FirstOrDefault();

               // Create an Installation token for Installation installation.Id
               if (installation != null)
                   installationToken = await appClient.GitHubApps.CreateInstallationToken(installation.Id);
               if (installationToken != null)
                   client = new GitHubClient(new ProductHeaderValue(StaticData.AppName))
                       {Credentials = new Credentials(installationToken.Token, AuthenticationType.Bearer)};
           }

           return client;
       }

using static Octokit.GraphQL.Variable;


       private async Task UseCase1()
       {
           var connection = await _currentGitHubClientManager.GetGraphQlConnection();

           var query = new Query()
               .RepositoryOwner(Var("owner"))
               .Repository(Var("name"))
               .Select(repo => new
               {
                   repo.Id,
                   repo.Name,
                   repo.Owner.Login,
                   repo.IsFork,
                   repo.IsPrivate,
               }).Compile();

           var vars = new Dictionary<string, object>
           {
               { "owner", "octokit" },
               { "name", "octokit.graphql.net" },
           };

           var result = await connection.Run(query, vars);
       }