public void EnsuresNonNullArguments() { Assert.Throws<ArgumentNullException>(() => new GitHubClient((IConnection)null)); Assert.Throws<ArgumentNullException>(() => new GitHubClient((ProductHeaderValue)null)); var productInformation = new ProductHeaderValue("UnitTest"); var baseAddress = new Uri("http://github.com"); var credentialStore = Substitute.For<ICredentialStore>(); Assert.Throws<ArgumentNullException>(() => new GitHubClient(productInformation, (ICredentialStore)null)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(null, credentialStore)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(productInformation, (Uri)null)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(null, baseAddress)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(null, (ICredentialStore)null)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(null, (Uri)null)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(productInformation, null, null)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(null, credentialStore, null)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(null, null, baseAddress)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(null, credentialStore, baseAddress)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(productInformation, null, baseAddress)); Assert.Throws<ArgumentNullException>(() => new GitHubClient(productInformation, credentialStore, null)); }
public ProductInfoHeaderValue (ProductHeaderValue product) { if (product == null) throw new ArgumentNullException (); Product = product; }
public static bool TryParse(string input, out ProductHeaderValue parsedValue) { System.Net.Http.Headers.ProductHeaderValue value; var result = System.Net.Http.Headers.ProductHeaderValue.TryParse(input, out value); parsedValue = result ? Parse(input) : null; return result; }
public ProductInfoHeaderValue (string productName, string productVersion) { Product = new ProductHeaderValue (productName, productVersion); }
static async Task Main(string[] args) { var token = "the token"; var productInformation = new ProductHeaderValue("OctokitBugRepro"); var client = new GitHubClient(productInformation); client.Credentials = new Credentials(token); Console.WriteLine("Get teams..."); var allTeams = await client.Organization.Team.GetAll("dotnet"); var msTeam = allTeams.Single(t => string.Equals(t.Name, "Microsoft", StringComparison.OrdinalIgnoreCase)); Console.WriteLine("Get members..."); var members = await client.Organization.Team.GetAllMembers(msTeam.Id, new TeamMembersRequest(TeamRoleFilter.Member)); var logins = new SortedSet <string>(members.Select(m => m.Login)); Console.WriteLine(logins.Count); var folks = logins.Where(m => m.StartsWith("opb", StringComparison.OrdinalIgnoreCase)) .ToArray(); foreach (var f in folks) { Console.WriteLine(f); } // prints: // 665 // // no users // // Here is what it should display: // 1246 // that's the number of members according to the web UI // opbld10 // opbld11 // opbld12 // opbld13 // opbld14 // opbld15 // opbld16 // opbld17 // opbld18 // opbld19 // opbld20 // opbld21 // opbld22 // opbld25 // opbld26 // opbld27 // opbld28 // opbld29 // opbld30 // opbld31 // opbld32 // opbld33 // opbld34 // opbld35 // opbld36 // opbld37 // opbld38 // opbld39 // opbld40 // opbld41 // opbld42 // opbld43 // opbld44 // opbld45 // opbld47 // opbld48 // opbld49 // opbld50 // opbld51 // opbld52 // opbld53 // opbld54 // opbld55 // opbld56 // opbldsb1 // opbldsb2 // opbldsb3 // opbldsb6 // opbldsb7 // opbldsb9 }
public ObservableGitHubClient(ProductHeaderValue productInformation, ICredentialStore credentialStore, Uri baseAddress) : this(new GitHubClient(productInformation, credentialStore, baseAddress)) { }
public ProductInfoHeaderValue(string productName, string productVersion) { Product = new ProductHeaderValue(productName, productVersion); }
public GitHubGraphQLClient(ProductHeaderValue headerValue, string accessToken) { _connection = new Connection(headerValue, accessToken); }
public ObservableGitHubClient(ProductHeaderValue productInformation) : this(new GitHubClient(productInformation)) { }
public ApiClientFactory(IKeychain keychain, IProgram program) { Keychain = keychain; productHeader = program.ProductHeader; }
/// <summary> /// Create a new instance of the GitHub API v3 client pointing to the specified baseAddress. /// </summary> /// <param name="productInformation"> /// The name (and optionally version) of the product using this library. This is sent to the server as part of /// the user agent for analytics purposes. /// </param> /// <param name="baseAddress"> /// The address to point this client to. Typically used for GitHub Enterprise /// instances</param> public GitHubClient(ProductHeaderValue productInformation, Uri baseAddress) : this(new Connection(productInformation, FixUpBaseUri(baseAddress))) { }
private static GitHubClient GetClient(ProductHeaderValue productInformation) { var client = new GitHubClient(productInformation); return(client); }
private void Form2_Load(object sender, EventArgs e) { var productiInformation = new ProductHeaderValue(client.Credentials.Login); GetAllRepositariesForProject(); }
public ApiClientFactory(ILoginCache loginCache, IProgram program, ILoggingConfiguration config) { LoginCache = loginCache; productHeader = program.ProductHeader; config.Configure(); }
public GitHubClient(ProductHeaderValue productHeaderValue, InMemoryCredentialStore inMemoryCredentialStore) { this.productHeaderValue = productHeaderValue; this.inMemoryCredentialStore = inMemoryCredentialStore; }
public static bool TryParse(string input, out ProductHeaderValue parsedValue) { throw new NotImplementedException(); }
private bool TryGetClient(ProductHeaderValue productInformation, out GitHubClient client) { client = AuthenticateBasic(productInformation, _gitHubUser, _githubPassword); return(client != null); }
/// <summary> /// Create a new instance of the GitHub API v3 client pointing to /// https://api.github.com/ /// </summary> /// <param name="productInformation"> /// The name (and optionally version) of the product using this library. This is sent to the server as part of /// the user agent for analytics purposes. /// </param> public GitHubClient(ProductHeaderValue productInformation) : this(new Connection(productInformation)) { }
/// <summary> /// Sets the User-Agent header of the request to the specified product. /// </summary> /// <param name="product">The Upgrade header product.</param> /// <returns>An <see cref="IRequest"/> object that represents the request.</returns> public static IRequest UserAgent(this IWith @this, ProductHeaderValue product) => @this.UserAgent(new ProductInfoHeaderValue(product));
/// <summary> /// Sets the Upgrade header of the request to the specified value. /// </summary> /// <param name="value">The Upgrade header value.</param> /// <returns>An <see cref="IRequest"/> object that represents the request.</returns> public static IRequest Upgrade(this IWith @this, ProductHeaderValue value) => @this.AddHeaderValue(headers => headers.Upgrade, value);
static BaseService() { clientHandler.CookieContainer = CookiesContainer; client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*")); client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(ProductHeaderValue.Parse("Mozilla/5.0")));// (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36 }
private GitHubClient AuthenticateBasic(ProductHeaderValue productInformation, string user, string pass) { //_log.Info("trying to get a GitHub client{productInformation}", productInformation); return(GetClient(productInformation, user, pass)); }
public static async Task SyncFromGitHub(string repoUrl, string token, DirectoryInfo releaseDirectoryInfo) { var repoUri = new Uri(repoUrl); var userAgent = new ProductHeaderValue("SyncReleases", Assembly.GetExecutingAssembly().GetName().Version.ToString()); var client = new GitHubClient(userAgent, repoUri); if (token != null) { client.Credentials = new Credentials(token); } var nwo = nwoFromRepoUrl(repoUrl); var releases = (await client.Release.GetAll(nwo.Item1, nwo.Item2)) .OrderByDescending(x => x.PublishedAt) .Take(5); await releases.ForEachAsync(async release => { // NB: Why do I have to double-fetch the release assets? It's already in GetAll var assets = await client.Release.GetAllAssets(nwo.Item1, nwo.Item2, release.Id); await assets .Where(x => x.Name.EndsWith(".nupkg", StringComparison.OrdinalIgnoreCase)) .Where(x => { var fi = new FileInfo(Path.Combine(releaseDirectoryInfo.FullName, x.Name)); return(!(fi.Exists && fi.Length == x.Size)); }) .ForEachAsync(async x => { var target = new FileInfo(Path.Combine(releaseDirectoryInfo.FullName, x.Name)); if (target.Exists) { target.Delete(); } await retryAsync(3, async() => { var hc = new HttpClient(); var rq = new HttpRequestMessage(HttpMethod.Get, x.Url); rq.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/octet-stream")); rq.Headers.UserAgent.Add(new System.Net.Http.Headers.ProductInfoHeaderValue(userAgent.Name, userAgent.Version)); if (token != null) { rq.Headers.Add("Authorization", "Bearer " + token); } var resp = await hc.SendAsync(rq); resp.EnsureSuccessStatusCode(); using (var from = await resp.Content.ReadAsStreamAsync()) using (var to = File.OpenWrite(target.FullName)) { await from.CopyToAsync(to); } }); }); }); var entries = releaseDirectoryInfo.GetFiles("*.nupkg") .AsParallel() .Select(x => ReleaseEntry.GenerateFromFile(x.FullName)); ReleaseEntry.WriteReleaseFile(entries, Path.Combine(releaseDirectoryInfo.FullName, "RELEASES")); }
public ObservableGitHubClient(ProductHeaderValue productInformation, Uri baseAddress) : this(new GitHubClient(productInformation, baseAddress)) { }
public EnterpriseProbeTask(IProgram program, IHttpClient httpClient) { productHeader = program.ProductHeader; this.httpClient = httpClient; }
public ProductInfoHeaderValue(ProductHeaderValue product) { Product = product; }
public SimpleApiClientFactory(IProgram program, Lazy <IEnterpriseProbeTask> enterpriseProbe, Lazy <IWikiProbe> wikiProbe) { productHeader = program.ProductHeader; lazyEnterpriseProbe = enterpriseProbe; lazyWikiProbe = wikiProbe; }
public MetricsService(Lazy <IHttpClient> httpClient, IProgram program) { this.httpClient = httpClient; this.productHeader = program.ProductHeader; }
private static ObservableGitHubClient CreateClient(this ProductHeaderValue header) => new ObservableGitHubClient(header);
public static bool TryParse (string input, out ProductHeaderValue parsedValue) { parsedValue = null; var lexer = new Lexer (input); var t = lexer.Scan (); if (t != Token.Type.Token) return false; var value = new ProductHeaderValue (); value.Name = lexer.GetStringValue (t); t = lexer.Scan (); if (t == Token.Type.SeparatorSlash) { t = lexer.Scan (); if (t != Token.Type.Token) return false; value.Version = lexer.GetStringValue (t); t = lexer.Scan (); } if (t != Token.Type.End) return false; parsedValue = value; return true; }
/// <summary> /// Construct a <see cref="ServerClientFactory"/> /// </summary> /// <param name="productHeaderValue">The value of <see cref="productHeaderValue"/></param> public ServerClientFactory(ProductHeaderValue productHeaderValue) { this.productHeaderValue = productHeaderValue ?? throw new ArgumentNullException(nameof(productHeaderValue)); }
private void CheckValidParse(string input, ProductHeaderValue expectedResult) { ProductHeaderValue result = ProductHeaderValue.Parse(input); Assert.Equal(expectedResult, result); }
private void CheckInvalidParse(string input) { Assert.Throws <FormatException>(() => { ProductHeaderValue.Parse(input); }); }
private static void CallGetProductLength(string input, int startIndex, int expectedLength, out ProductHeaderValue result) { Assert.Equal(expectedLength, ProductHeaderValue.GetProductLength(input, startIndex, out result)); }
public ApiConnection(string productName, string productVersion) { _throttler = new Throttler(20, TimeSpan.FromMinutes(1)); _productInformation = new ProductHeaderValue(productName, productVersion); }
/// <summary> /// Create a new instance of the GitHub API v3 client pointing to /// https://api.github.com/ /// </summary> /// <param name="productInformation"> /// The name (and optionally version) of the product using this library. This is sent to the server as part of /// the user agent for analytics purposes. /// </param> /// <param name="credentialStore">Provides credentials to the client when making requests.</param> public GitHubClient(ProductHeaderValue productInformation, ICredentialStore credentialStore) : this(new Connection(productInformation, credentialStore)) { }
private GitHubClient AuthenticateToken(ProductHeaderValue productionInformation, string token) { //_log.Info("trying to get a GitHub client {productInformation} with token {token}", productInformation, token); return(GetClient(productionInformation, token)); }
/// <summary> /// Create a new instance of the GitHub API v3 client pointing to the specified baseAddress. /// </summary> /// <param name="productInformation"> /// The name (and optionally version) of the product using this library. This is sent to the server as part of /// the user agent for analytics purposes. /// </param> /// <param name="credentialStore">Provides credentials to the client when making requests.</param> /// <param name="baseAddress"> /// The address to point this client to. Typically used for GitHub Enterprise /// instances</param> public GitHubClient(ProductHeaderValue productInformation, ICredentialStore credentialStore, Uri baseAddress) : this(new Connection(productInformation, FixUpBaseUri(baseAddress), credentialStore)) { }
/**************************************************************************/ // TODO: Implement this: /* * public async Task<MacroscopeHttpTwoClientResponse> Post () * { * * ConfigureProxy(); * * MacroscopeHttpTwoClientResponse ClientResponse = null; * return ( ClientResponse ); * } */ /**************************************************************************/ // https://en.wikipedia.org/wiki/List_of_HTTP_header_fields private void ConfigureDefaultRequestHeaders(HttpRequestMessage Request) { try { Request.Headers.Host = Request.RequestUri.Host; } catch (Exception ex) { this.DebugMsg(string.Format("Get: {0}", ex.Message)); } try { ProductHeaderValue ProductHeaderValueUserAgent = new ProductHeaderValue(this.UserAgentName(), this.UserAgentVersion()); ProductInfoHeaderValue ProductInfoHeaderValueUserAgent = new ProductInfoHeaderValue(ProductHeaderValueUserAgent); Request.Headers.UserAgent.Clear(); Request.Headers.UserAgent.Add(ProductInfoHeaderValueUserAgent); } catch (Exception ex) { this.DebugMsg(ex.Message); } try { if (Request.Headers.Accept != null) { Request.Headers.Accept.Clear(); Request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*", 1)); } } catch (Exception ex) { this.DebugMsg(ex.Message); } try { if (Request.Headers.AcceptCharset != null) { Request.Headers.AcceptCharset.Clear(); Request.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8", 1)); Request.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("us-ascii", 0.9)); } } catch (Exception ex) { this.DebugMsg(ex.Message); } try { if (Request.Headers.AcceptEncoding != null) { Request.Headers.AcceptEncoding.Clear(); Request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip", 1)); Request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate", 0.9)); } } catch (Exception ex) { this.DebugMsg(ex.Message); throw; } try { // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control if (Request.Headers.CacheControl != null) { Request.Headers.CacheControl.MaxAge = new TimeSpan(0, 0, 0); Request.Headers.CacheControl.NoCache = true; Request.Headers.CacheControl.MustRevalidate = true; Request.Headers.CacheControl.ProxyRevalidate = true; } } catch (Exception ex) { this.DebugMsg(ex.Message); } try { if (Request.Headers.AcceptLanguage != null) { Request.Headers.AcceptLanguage.Clear(); Request.Headers.AcceptLanguage.Add(new StringWithQualityHeaderValue("*", 1)); } } catch (Exception ex) { this.DebugMsg(ex.Message); } try { // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/DNT Request.Headers.Add("DNT", "1"); } catch (Exception ex) { this.DebugMsg(ex.Message); } try { // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Upgrade-Insecure-Requests Request.Headers.Add("Upgrade-Insecure-Requests", "1"); } catch (Exception ex) { this.DebugMsg(ex.Message); } }