github_api-0.18.2/0000755000004100000410000000000013214644262013751 5ustar www-datawww-datagithub_api-0.18.2/github_api.gemspec0000644000004100000410000001737413214644262017445 0ustar www-datawww-data######################################################### # This file has been automatically generated by gem2tgz # ######################################################### # -*- encoding: utf-8 -*- Gem::Specification.new do |s| s.name = "github_api" s.version = "0.18.2" s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= s.authors = ["Piotr Murach"] s.date = "2017-11-19" s.description = " Ruby client that supports all of the GitHub API methods. It's build in a modular way, that is, you can either instantiate the whole api wrapper Github.new or use parts of it e.i. Github::Client::Repos.new if working solely with repositories is your main concern. Intuitive query methods allow you easily call API endpoints. " s.email = "" s.extra_rdoc_files = ["LICENSE.txt", "README.md"] s.files = ["LICENSE.txt", "README.md", "lib/github_api.rb", "lib/github_api/api.rb", "lib/github_api/api/actions.rb", "lib/github_api/api/arguments.rb", "lib/github_api/api/config.rb", "lib/github_api/api/config/property.rb", "lib/github_api/api/config/property_set.rb", "lib/github_api/api/factory.rb", "lib/github_api/authorization.rb", "lib/github_api/client.rb", "lib/github_api/client/activity.rb", "lib/github_api/client/activity/events.rb", "lib/github_api/client/activity/feeds.rb", "lib/github_api/client/activity/notifications.rb", "lib/github_api/client/activity/starring.rb", "lib/github_api/client/activity/watching.rb", "lib/github_api/client/authorizations.rb", "lib/github_api/client/authorizations/app.rb", "lib/github_api/client/emojis.rb", "lib/github_api/client/gists.rb", "lib/github_api/client/gists/comments.rb", "lib/github_api/client/git_data.rb", "lib/github_api/client/git_data/blobs.rb", "lib/github_api/client/git_data/commits.rb", "lib/github_api/client/git_data/references.rb", "lib/github_api/client/git_data/tags.rb", "lib/github_api/client/git_data/trees.rb", "lib/github_api/client/gitignore.rb", "lib/github_api/client/issues.rb", "lib/github_api/client/issues/assignees.rb", "lib/github_api/client/issues/comments.rb", "lib/github_api/client/issues/events.rb", "lib/github_api/client/issues/labels.rb", "lib/github_api/client/issues/milestones.rb", "lib/github_api/client/markdown.rb", "lib/github_api/client/meta.rb", "lib/github_api/client/orgs.rb", "lib/github_api/client/orgs/hooks.rb", "lib/github_api/client/orgs/members.rb", "lib/github_api/client/orgs/memberships.rb", "lib/github_api/client/orgs/projects.rb", "lib/github_api/client/orgs/teams.rb", "lib/github_api/client/projects.rb", "lib/github_api/client/projects/cards.rb", "lib/github_api/client/projects/columns.rb", "lib/github_api/client/pull_requests.rb", "lib/github_api/client/pull_requests/comments.rb", "lib/github_api/client/pull_requests/reviews.rb", "lib/github_api/client/repos.rb", "lib/github_api/client/repos/branches.rb", "lib/github_api/client/repos/branches/protections.rb", "lib/github_api/client/repos/collaborators.rb", "lib/github_api/client/repos/comments.rb", "lib/github_api/client/repos/commits.rb", "lib/github_api/client/repos/contents.rb", "lib/github_api/client/repos/deployments.rb", "lib/github_api/client/repos/downloads.rb", "lib/github_api/client/repos/forks.rb", "lib/github_api/client/repos/hooks.rb", "lib/github_api/client/repos/keys.rb", "lib/github_api/client/repos/merging.rb", "lib/github_api/client/repos/pages.rb", "lib/github_api/client/repos/projects.rb", "lib/github_api/client/repos/pub_sub_hubbub.rb", "lib/github_api/client/repos/releases.rb", "lib/github_api/client/repos/releases/assets.rb", "lib/github_api/client/repos/releases/tags.rb", "lib/github_api/client/repos/statistics.rb", "lib/github_api/client/repos/statuses.rb", "lib/github_api/client/say.rb", "lib/github_api/client/scopes.rb", "lib/github_api/client/search.rb", "lib/github_api/client/search/legacy.rb", "lib/github_api/client/users.rb", "lib/github_api/client/users/emails.rb", "lib/github_api/client/users/followers.rb", "lib/github_api/client/users/keys.rb", "lib/github_api/configuration.rb", "lib/github_api/connection.rb", "lib/github_api/constants.rb", "lib/github_api/core_ext/array.rb", "lib/github_api/core_ext/hash.rb", "lib/github_api/core_ext/ordered_hash.rb", "lib/github_api/deprecation.rb", "lib/github_api/error.rb", "lib/github_api/error/client_error.rb", "lib/github_api/error/service_error.rb", "lib/github_api/ext/faraday.rb", "lib/github_api/mash.rb", "lib/github_api/middleware.rb", "lib/github_api/mime_type.rb", "lib/github_api/normalizer.rb", "lib/github_api/null_encoder.rb", "lib/github_api/page_iterator.rb", "lib/github_api/page_links.rb", "lib/github_api/paged_request.rb", "lib/github_api/pagination.rb", "lib/github_api/parameter_filter.rb", "lib/github_api/params_hash.rb", "lib/github_api/rate_limit.rb", "lib/github_api/request.rb", "lib/github_api/request/basic_auth.rb", "lib/github_api/request/jsonize.rb", "lib/github_api/request/oauth2.rb", "lib/github_api/request/verbs.rb", "lib/github_api/requestable.rb", "lib/github_api/resource.rb", "lib/github_api/response.rb", "lib/github_api/response/atom_parser.rb", "lib/github_api/response/follow_redirects.rb", "lib/github_api/response/header.rb", "lib/github_api/response/jsonize.rb", "lib/github_api/response/mashify.rb", "lib/github_api/response/raise_error.rb", "lib/github_api/response/xmlize.rb", "lib/github_api/response_wrapper.rb", "lib/github_api/ssl_certs/cacerts.pem", "lib/github_api/utils/url.rb", "lib/github_api/validations.rb", "lib/github_api/validations/format.rb", "lib/github_api/validations/presence.rb", "lib/github_api/validations/required.rb", "lib/github_api/validations/token.rb", "lib/github_api/version.rb"] s.homepage = "http://piotrmurach.github.io/github/" s.licenses = ["MIT"] s.require_paths = ["lib"] s.required_ruby_version = Gem::Requirement.new(">= 2.0.0") s.rubygems_version = "1.8.23" s.summary = "Ruby client for the official GitHub API" if s.respond_to? :specification_version then s.specification_version = 4 if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then s.add_runtime_dependency(%q, ["~> 2.4"]) s.add_development_dependency(%q, ["< 2.0", ">= 1.5.0"]) s.add_development_dependency(%q, ["~> 2.1"]) s.add_runtime_dependency(%q, ["~> 0.0.4"]) s.add_runtime_dependency(%q, ["~> 0.8"]) s.add_runtime_dependency(%q, [">= 3.5.2", "~> 3.5"]) s.add_runtime_dependency(%q, ["~> 1.0"]) s.add_development_dependency(%q, ["< 11.0"]) s.add_development_dependency(%q, ["~> 2.14.1"]) s.add_development_dependency(%q, ["~> 3.0.3"]) s.add_development_dependency(%q, ["~> 3.0.1"]) else s.add_dependency(%q, ["~> 2.4"]) s.add_dependency(%q, ["< 2.0", ">= 1.5.0"]) s.add_dependency(%q, ["~> 2.1"]) s.add_dependency(%q, ["~> 0.0.4"]) s.add_dependency(%q, ["~> 0.8"]) s.add_dependency(%q, [">= 3.5.2", "~> 3.5"]) s.add_dependency(%q, ["~> 1.0"]) s.add_dependency(%q, ["< 11.0"]) s.add_dependency(%q, ["~> 2.14.1"]) s.add_dependency(%q, ["~> 3.0.3"]) s.add_dependency(%q, ["~> 3.0.1"]) end else s.add_dependency(%q, ["~> 2.4"]) s.add_dependency(%q, ["< 2.0", ">= 1.5.0"]) s.add_dependency(%q, ["~> 2.1"]) s.add_dependency(%q, ["~> 0.0.4"]) s.add_dependency(%q, ["~> 0.8"]) s.add_dependency(%q, [">= 3.5.2", "~> 3.5"]) s.add_dependency(%q, ["~> 1.0"]) s.add_dependency(%q, ["< 11.0"]) s.add_dependency(%q, ["~> 2.14.1"]) s.add_dependency(%q, ["~> 3.0.3"]) s.add_dependency(%q, ["~> 3.0.1"]) end end github_api-0.18.2/LICENSE.txt0000644000004100000410000000204013214644262015570 0ustar www-datawww-dataCopyright (c) 2011 Piotr Murach Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. github_api-0.18.2/lib/0000755000004100000410000000000013214644262014517 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/0000755000004100000410000000000013214644262016632 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/core_ext/0000755000004100000410000000000013214644262020442 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/core_ext/hash.rb0000644000004100000410000000417413214644262021720 0ustar www-datawww-data# encoding: utf-8 class Hash # :nodoc: # Returns a new hash with keys removed # def except(*items) self.dup.except!(*items) end unless method_defined? :except # Similar to except but modifies self # def except!(*keys) keys.each { |key| delete(key) } self end unless method_defined? :except! # Returns a new hash with all the keys converted to symbols # def symbolize_keys inject({}) do |hash, (key, value)| hash[(key.to_sym rescue key) || key] = value hash end end unless method_defined? :symbolize_keys # Similar to symbolize_keys but modifies self # def symbolize_keys! hash = symbolize_keys hash.each do |key, val| hash[key] = case val when Hash val.symbolize_keys! when Array val.map do |item| item.is_a?(Hash) ? item.symbolize_keys! : item end else val end end return hash end unless method_defined? :symbolize_keys! # Returns hash collapsed into a query string # def serialize self.map { |key, val| [key, val].join("=") }.join("&") end unless method_defined? :serialize # Searches for all deeply nested keys # def deep_keys keys = self.keys keys.each do |key| if self[key].is_a?(Hash) keys << self[key].deep_keys.compact.flatten next end end keys.flatten end unless method_defined? :deep_keys # Returns true if the given key is present inside deeply nested hash # def deep_key?(key) self.deep_keys.include? key end unless method_defined? :deep_key? # Recursively merges self with other hash and returns new hash. # def deep_merge(other, &block) dup.deep_merge!(other, &block) end unless method_defined? :deep_merge # Similar as deep_merge but modifies self # def deep_merge!(other, &block) other.each_pair do |key, val| tval = self[key] if tval.is_a?(Hash) && val.is_a?(Hash) self[key] = tval.deep_merge(val) else self[key] = block && tval ? block.call(k, tval, val) : val end end self end unless method_defined? :deep_merge! end # Hash github_api-0.18.2/lib/github_api/core_ext/ordered_hash.rb0000644000004100000410000000403213214644262023415 0ustar www-datawww-data# encoding: utf-8 module Github module CoreExt #:nodoc: if RUBY_VERSION >= '1.9' class OrderedHash < ::Hash; end else class OrderedHash < ::Hash attr_accessor :order class << self def [](*args) hsh = OrderedHash.new if Hash == args[0] hsh.replace args[0] elsif (args.size % 2) != 0 pp args if ENV['DEBUG'] raise ArgumentError, "odd number of elements for Hash" else 0.step(args.size - 1, 2) do |a| b = a + 1 hsh[args[a]] = args[b] end end hsh end end def initialize(*args, &block) super @order = [] end def []=(key, value) @order.push key unless member?(key) super key, value end def ==(hsh2) return false if @order != hsh2.order super hsh2 end def clear @order = [] super end def delete(key) @order.delete key super end def each_key @order.each { |k| yield k } self end def each_value @order.each { |k| yield self[k] } self end def each @order.each { |k| yield k, self[k] } self end alias :each_pair :each def delete_if @order.clone.each { |k| delete k if yield } self end def values ary = [] @order.each { |k| ary.push self[k] } ary end def keys @order end def replace(hsh2) @order = hsh2.keys super hsh2 end def shift key = @order.first key ? [key, delete(key)] : super end def class Hash end def __class__ OrderedHash end end # OrderedHash end end # CoreExt end # Github github_api-0.18.2/lib/github_api/core_ext/array.rb0000644000004100000410000000101113214644262022076 0ustar www-datawww-data# encoding: utf-8 class Array # :nodoc: # Returns a new arrray with keys removed # def except(*keys) self.dup.except!(*keys) end unless method_defined? :except # Similar to except but modifies self # def except!(*items) copy = self.dup copy.reject! { |item| items.include? item } copy end unless method_defined? :except! # Selects a hash from the arguments list # def extract_options! last.is_a?(::Hash) ? pop : {} end unless method_defined? :extract_options! end # Array github_api-0.18.2/lib/github_api/configuration.rb0000644000004100000410000000362413214644262022033 0ustar www-datawww-data# encoding: utf-8 require_relative 'api/config' require_relative 'version' module Github # Stores the configuration class Configuration < API::Config # Other adapters are :typhoeus, :patron, :em_synchrony, :excon, :test property :adapter, default: :net_http # By default, don't traverse the page links property :auto_pagination, default: false property :follow_redirects, default: true # Basic authentication property :basic_auth # By default, don't set an application key property :client_id # By default, don't set an application secret property :client_secret # By default, don't set a user oauth access token property :oauth_token # The api endpoint used to connect to GitHub if none is set property :endpoint, default: 'https://api.github.com'.freeze # The web endpoint used to connect to GitHub if none is set property :site, default: 'https://github.com'.freeze # The web endpoint used to upload release assets to GitHub if none is set property :upload_endpoint, default: 'https://uploads.github.com'.freeze # The default SSL configuration property :ssl, default: { :ca_file => File.expand_path('../ssl_certs/cacerts.pem', __FILE__) } # By default the Accept header will make a request for JSON property :mime_type # The value sent in the http header for 'User-Agent' if none is set property :user_agent, default: "Github API Ruby Gem #{Github::VERSION}".freeze # By default uses the Faraday connection options if none is set property :connection_options, default: {} # Global repository name property :repo property :user property :org property :login property :password # By default display 30 resources property :per_page, default: 30 # Add Faraday::RackBuilder to overwrite middleware property :stack end # Configuration end # Github github_api-0.18.2/lib/github_api/deprecation.rb0000644000004100000410000000140613214644262021455 0ustar www-datawww-data# encoding: utf-8 module Github DEPRECATION_PREFIX = "[GithubAPI] Deprecation warning:" class << self attr_writer :deprecation_tracker def deprecation_tracker @deprecation_tracker ||= [] end # Displays deprecation message to the user. # Each message is printed once. def deprecate(method, alternate_method=nil) return if deprecation_tracker.include? method deprecation_tracker << method message = <<-NOTICE #{DEPRECATION_PREFIX} * #{method} is deprecated. NOTICE if alternate_method message << <<-ADDITIONAL * please use #{alternate_method} instead. ADDITIONAL end warn_deprecation(message) end def warn_deprecation(message) send :warn, message end end end # Github github_api-0.18.2/lib/github_api/pagination.rb0000644000004100000410000000724013214644262021313 0ustar www-datawww-data# encoding: utf-8 require_relative 'constants' require_relative 'page_links' require_relative 'page_iterator' module Github # A module that decorates response with pagination helpers module Pagination include Github::Constants # Return page links def links @links = Github::PageLinks.new(env[:response_headers]) end # Retrive number of total pages base on current :per_page parameter def count_pages page_iterator.count.to_i end # Iterate over results set pages by automatically calling `next_page` # until all pages are exhausted. Caution needs to be exercised when # using this feature - 100 pages iteration will perform 100 API calls. # By default this is off. You can set it on the client, individual API # instances or just per given request. # def auto_paginate(auto=false) if (current_api.auto_pagination? || auto) && self.body.is_a?(Array) resources_bodies = [] each_page { |resource| resources_bodies += resource.body } self.body = resources_bodies end self end # Iterator like each for response pages. If there are no pages to # iterate over this method will return current page. def each_page yield self while page_iterator.next? yield next_page end end # Retrives the result of the first page. Returns nil if there is # no first page - either because you are already on the first page # or there are no pages at all in the result. def first_page first_request = page_iterator.first self.instance_eval { @env = first_request.env } if first_request first_request end # Retrives the result of the next page. Returns nil if there is # no next page or no pages at all. def next_page next_request = page_iterator.next self.instance_eval { @env = next_request.env } if next_request next_request end # Retrives the result of the previous page. Returns nil if there is # no previous page or no pages at all. def prev_page prev_request = page_iterator.prev self.instance_eval { @env = prev_request.env } if prev_request prev_request end alias :previous_page :prev_page # Retrives the result of the last page. Returns nil if there is # no last page - either because you are already on the last page, # there is only one page or there are no pages at all in the result. def last_page last_request = page_iterator.last self.instance_eval { @env = last_request.env } if last_request last_request end # Retrives a specific result for a page given page number. # The page_number parameter is not validate, hitting a page # that does not exist will return Github API error. Consequently, if # there is only one page, this method returns nil def page(page_number) request = page_iterator.get_page(page_number) self.instance_eval { @env = request.env } if request request end # Returns true if there is another page in the result set, # otherwise false def has_next_page? page_iterator.next? end # Handle pagination params when they are not passed directly # def self.per_page_as_param(per_page_config) params = {} if (per_page_config != Github::Configuration.property_set[:per_page]) params[:per_page] = per_page_config unless per_page_config.nil? end params end private # Internally used page iterator def page_iterator # :nodoc: @page_iterator = Github::PageIterator.new(links, current_api) end end # Pagination end # Github github_api-0.18.2/lib/github_api/connection.rb0000644000004100000410000000404513214644262021321 0ustar www-datawww-data# encoding: utf-8 require 'faraday' require_relative 'constants' module Github # Specifies Http connection options module Connection extend self include Github::Constants ALLOWED_OPTIONS = [ :headers, :url, :params, :request, :ssl ].freeze # Default requets header information # # @return [Hash[String]] # # @api private def default_headers { ACCEPT => 'application/vnd.github.v3+json,' \ 'application/vnd.github.beta+json;q=0.5,' \ 'application/json;q=0.1', ACCEPT_CHARSET => 'utf-8' } end # Create default connection options # # @return [Hash[Symbol]] # the default options # # @api private def default_options(options = {}) headers = default_headers.merge(options[:headers] || {}) headers.merge!({USER_AGENT => options[:user_agent]}) { headers: headers, ssl: options[:ssl], url: options[:endpoint] } end # Exposes middleware builder to facilitate custom stacks and easy # addition of new extensions such as cache adapter. # # @api public def stack(options = {}) @stack ||= begin builder_class = if defined?(Faraday::RackBuilder) Faraday::RackBuilder else Faraday::Builder end builder_class.new(&Github.default_middleware(options)) end end # Creates http connection # # Returns a Fraday::Connection object def connection(api, options = {}) connection_options = default_options(options) connection_options.merge!(builder: stack(options.merge!(api: api))) if options[:connection_options] connection_options.deep_merge!(options[:connection_options]) end if ENV['DEBUG'] p "Connection options : \n" pp connection_options end Faraday.new(connection_options) end end # Connection end # Github github_api-0.18.2/lib/github_api/response.rb0000644000004100000410000000211013214644262021007 0ustar www-datawww-data# encoding: utf-8 require 'faraday' module Github # Contains methods and attributes that act on the response returned from the # request class Response < Faraday::Response::Middleware CONTENT_TYPE = 'Content-Type'.freeze class << self attr_accessor :parser end def self.define_parser(&block) @parser = block end def initialize(app, options = {}) super(app) @content_types = Array(options[:content_type]) end def process_body(env) env[:body] = parse(env[:body]) end def parse_body?(env) parse_response_type?(response_type(env)) and parse_response?(env) end def response_type(env) type = env[:response_headers][CONTENT_TYPE].to_s type = type.split(';', 2).first if type.index(';') type end def parse_response_type?(type) @content_types.empty? || @content_types.any? { |pattern| pattern.is_a?(Regexp) ? type =~ pattern : type == pattern } end def parse_response?(env) env[:body].respond_to?(:to_str) end end # Response end # Github github_api-0.18.2/lib/github_api/rate_limit.rb0000644000004100000410000000071513214644262021313 0ustar www-datawww-data# encoding: utf-8 module Github module RateLimit def ratelimit(*args) arguments(args) get_request("/rate_limit", arguments.params).rate.limit end def ratelimit_remaining(*args) arguments(args) get_request("/rate_limit", arguments.params).rate.remaining end def ratelimit_reset(*args) arguments(args) get_request("/rate_limit", arguments.params).rate.reset end end # RateLimit end # Github github_api-0.18.2/lib/github_api/mime_type.rb0000644000004100000410000000137613214644262021156 0ustar www-datawww-data# encoding: utf-8 module Github module MimeType MEDIA_LOOKUP = { 'json' => 'json', 'blob' => 'raw', 'raw' => 'raw+json', 'text' => 'text+json', 'html' => 'html+json', 'full' => 'full+json' } # Parse media type param # def parse(media) version = 'v3' media.sub!(/^[.]*|[.]*$/,"") media = media.include?('+') ? media.split('+')[0] : media version, media = media.split('.') if media.include?('.') media_type = lookup_media(media) "application/vnd.github.#{version}.#{media_type}" end def lookup_media(name) MEDIA_LOOKUP.fetch(name) do raise ArgumentError, "Provided Media Type #{name} is not valid" end end end # MimeType end # Github github_api-0.18.2/lib/github_api/mash.rb0000644000004100000410000000015213214644262020105 0ustar www-datawww-data# frozen_string_literal: true module Github class Mash < ::Hashie::Mash disable_warnings end end github_api-0.18.2/lib/github_api/parameter_filter.rb0000644000004100000410000000166613214644262022515 0ustar www-datawww-data# encoding: utf-8 require_relative 'params_hash' require_relative 'validations' module Github # Allows you to specify parameters keys which will be preserved # in parameters hash and its subhashes. Any keys from the nested # hash that do not match will be removed. module ParameterFilter # Removes any keys from nested hashes that don't match predefiend keys # def filter!(keys, params, options={:recursive => true}) # :nodoc: case params when Hash, ParamsHash params.keys.each do |k, v| unless (keys.include?(k) or Github::Validations::VALID_API_KEYS.include?(k)) params.delete(k) else filter!(keys, params[k]) if options[:recursive] end end when Array params.map! do |el| filter!(keys, el) if options[:recursive] end else params end return params end end # Filter end # Github github_api-0.18.2/lib/github_api/response/0000755000004100000410000000000013214644262020470 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/response/mashify.rb0000644000004100000410000000072413214644262022460 0ustar www-datawww-data# encoding: utf-8 require 'faraday' require 'hashie' require 'github_api/mash' module Github class Response::Mashify < Response define_parser do |body| ::Github::Mash.new body end def parse(body) case body when Hash self.class.parser.call body when Array body.map { |item| item.is_a?(Hash) ? self.class.parser.call(item) : item } else body end end end # Response::Mashify end # Github github_api-0.18.2/lib/github_api/response/follow_redirects.rb0000644000004100000410000001116713214644262024371 0ustar www-datawww-datarequire 'faraday' require 'set' # First saw on octokit, then copied from lostisland/faraday_middleware # and adapted for this library. # # faraday_middleware/lib/faraday_middleware/response/follow_redirects.rb module Github # Public: Exception thrown when the maximum amount of requests is exceeded. class RedirectLimitReached < Faraday::Error::ClientError attr_reader :response def initialize(response) super "too many redirects; last one to: #{response['location']}" @response = response end end # Public: Follow HTTP 301, 302, 303, 307, and 308 redirects. # # For HTTP 301, 302, and 303, the original GET, POST, PUT, DELETE, or PATCH # request gets converted into a GET. With `:standards_compliant => true`, # however, the HTTP method after 301/302 remains unchanged. This allows you # to opt into HTTP/1.1 compliance and act unlike the major web browsers. # # This middleware currently only works with synchronous requests; i.e. it # doesn't support parallelism. # # If you wish to persist cookies across redirects, you could use # the faraday-cookie_jar gem: # # Faraday.new(:url => url) do |faraday| # faraday.use FaradayMiddleware::FollowRedirects # faraday.use :cookie_jar # faraday.adapter Faraday.default_adapter # end class Response::FollowRedirects < Faraday::Middleware # HTTP methods for which 30x redirects can be followed ALLOWED_METHODS = Set.new [:head, :options, :get, :post, :put, :patch, :delete] # HTTP redirect status codes that this middleware implements REDIRECT_CODES = Set.new [301, 302, 303, 307, 308] # Keys in env hash which will get cleared between requests ENV_TO_CLEAR = Set.new [:status, :response, :response_headers] # Default value for max redirects followed FOLLOW_LIMIT = 3 # Regex that matches characters that need to be escaped in URLs, sans # the "%" character which we assume already represents an escaped sequence. URI_UNSAFE = /[^\-_.!~*'()a-zA-Z\d;\/?:@&=+$,\[\]%]/ # Public: Initialize the middleware. # # options - An options Hash (default: {}): # :limit - A Numeric redirect limit (default: 3) # :standards_compliant - A Boolean indicating whether to respect # the HTTP spec when following 301/302 # (default: false) # :callback - A callable that will be called on redirects # with the old and new envs def initialize(app, options = {}) super(app) @options = options @convert_to_get = Set.new [303] @convert_to_get << 301 << 302 unless standards_compliant? end def call(env) perform_with_redirection(env, follow_limit) end private def convert_to_get?(response) ![:head, :options].include?(response.env[:method]) && @convert_to_get.include?(response.status) end def perform_with_redirection(env, follows) request_body = env[:body] response = @app.call(env) response.on_complete do |response_env| if follow_redirect?(response_env, response) raise RedirectLimitReached, response if follows.zero? new_request_env = update_env(response_env.dup, request_body, response) callback.call(response_env, new_request_env) if callback response = perform_with_redirection(new_request_env, follows - 1) end end response end def update_env(env, request_body, response) env[:url] += safe_escape(response['location']) if convert_to_get?(response) env[:method] = :get env[:body] = nil else env[:body] = request_body end ENV_TO_CLEAR.each {|key| env.delete key } env end def follow_redirect?(env, response) ALLOWED_METHODS.include? env[:method] and REDIRECT_CODES.include? response.status end def follow_limit @options.fetch(:limit, FOLLOW_LIMIT) end def standards_compliant? @options.fetch(:standards_compliant, false) end def callback @options[:callback] end # Internal: escapes unsafe characters from an URL which might be a path # component only or a fully qualified URI so that it can be joined onto an # URI:HTTP using the `+` operator. Doesn't escape "%" characters so to not # risk double-escaping. def safe_escape(uri) uri = uri.split('#')[0] # we want to remove the fragment if present uri.to_s.gsub(URI_UNSAFE) { |match| '%' + match.unpack('H2' * match.bytesize).join('%').upcase } end end end github_api-0.18.2/lib/github_api/response/xmlize.rb0000644000004100000410000000063213214644262022326 0ustar www-datawww-data# encoding: utf-8 require 'faraday' module Github class Response::Xmlize < Response dependency 'nokogiri' define_parser do |body| ::Nokogiri::XML body end def parse(body) case body when '' nil when 'true' true when 'false' false else self.class.parser.call(body) end end end # Response::Xmlize end # Github github_api-0.18.2/lib/github_api/response/jsonize.rb0000644000004100000410000000064313214644262022501 0ustar www-datawww-data# encoding: utf-8 require 'faraday' require 'json' module Github class Response::Jsonize < Response dependency 'json' define_parser do |body| JSON.parse(body) end def parse(body) case body when '' nil when 'true' true when 'false' false else self.class.parser.call(body) end end end # Response::Jsonize end # Github github_api-0.18.2/lib/github_api/response/header.rb0000644000004100000410000000356213214644262022253 0ustar www-datawww-data# encoding: utf-8 require_relative '../constants' module Github class Response # Represents http response header class Header < Struct.new(:env) include Github::Constants SUCCESSFUL_STATUSES = 200..299 def loaded? !!env end def [](property) loaded? ? env[:response_headers][property] : nil end def oauth_scopes loaded? ? env[:response_headers][OAUTH_SCOPES] : nil end def accepted_oauth_scopes loaded? ? env[:response_headers][ACCEPTED_OAUTH_SCOPES] : nil end # Requests are limited to API v3 to 5000 per hour. def ratelimit_limit loaded? ? env[:response_headers][RATELIMIT_LIMIT] : nil end def ratelimit_remaining loaded? ? env[:response_headers][RATELIMIT_REMAINING] : nil end # A unix timestamp describing when the ratelimit will # be reset def ratelimit_reset loaded? ? env[:response_headers][RATELIMIT_RESET] : nil end def cache_control loaded? ? env[:response_headers][CACHE_CONTROL] : nil end def content_type loaded? ? env[:response_headers][CONTENT_TYPE] : nil end def content_length loaded? ? env[:response_headers][CONTENT_LENGTH] : nil end def etag loaded? ? env[:response_headers][ETAG] : nil end def date loaded? ? env[:response_headers][DATE] : nil end def location loaded? ? env[:response_headers][LOCATION] : nil end def server loaded? ? env[:response_headers][SERVER] : nil end def status loaded? ? env[:status] : nil end def success? SUCCESSFUL_STATUSES.include? status end # Returns raw body def body loaded? ? env[:body] : nil end end # Header end # Response end # Github github_api-0.18.2/lib/github_api/response/raise_error.rb0000644000004100000410000000114613214644262023333 0ustar www-datawww-data# encoding: utf-8 require 'faraday' require_relative '../error/service_error' module Github class Response::RaiseError < Faraday::Response::Middleware # Check if status code requires raising a ServiceError # # @api private def on_complete(env) status_code = env[:status].to_i service_error = Github::Error::ServiceError error_class = service_error.error_mapping[status_code] if !error_class and (400...600) === status_code error_class = service_error end raise error_class.new(env) if error_class end end # Response::RaiseError end # Github github_api-0.18.2/lib/github_api/response/atom_parser.rb0000644000004100000410000000061313214644262023331 0ustar www-datawww-data# encoding: utf-8 require 'faraday' module Github class Response::AtomParser < Response define_parser do |body| require 'rss' RSS::Parser.parse(body) end def initialize(app, options = {}) super(app, options.merge(content_type: /(\batom|\brss)/)) end def on_complete(env) if parse_body?(env) process_body(env) end end end end github_api-0.18.2/lib/github_api/client.rb0000644000004100000410000000345313214644262020442 0ustar www-datawww-data# encoding: utf-8 require_relative 'api' module Github class Client < API require_all 'github_api/client', 'activity', 'authorizations', 'emojis', 'gists', 'gitignore', 'git_data', 'issues', 'markdown', 'meta', 'orgs', 'projects', 'pull_requests', 'repos', 'say', 'scopes', 'search', 'users' # Serving up the 'social' in Social Coding, the Activity APIs # provide access to notifications, subscriptions, and timelines. namespace :activity namespace :emojis namespace :gists namespace :gitignore alias :git_ignore :gitignore # The Git Database API gives you access to read and write raw Git objects # to your Git database on GitHub and to list and update your references # (branch heads and tags). namespace :git_data alias :git :git_data namespace :issues namespace :markdown namespace :meta # An API for users to manage their own tokens. You can only access your own # tokens, and only through Basic Authentication. namespace :authorizations alias :oauth :authorizations alias :auth :authorizations namespace :orgs alias :organizations :orgs namespace :projects namespace :pull_requests alias :pulls :pull_requests namespace :repos alias :repositories :repos namespace :say alias :octocat :say namespace :scopes namespace :search # Many of the resources on the users API provide a shortcut for getting # information about the currently authenticated user. namespace :users end # Client end # Github github_api-0.18.2/lib/github_api/api/0000755000004100000410000000000013214644262017403 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/api/factory.rb0000644000004100000410000000146613214644262021406 0ustar www-datawww-data# encoding: utf-8 require 'github_api/core_ext/hash' module Github class API class Factory # Instantiates a new github api object # def self.new(klass, options={}, &block) return create_instance(klass, options, &block) if klass raise ArgumentError, 'must provide API class to be instantiated' end # Passes configuration options to instantiated class # def self.create_instance(klass, options, &block) options.symbolize_keys! convert_to_constant(klass.to_s).new options, &block end # Convert name to constant # def self.convert_to_constant(classes) classes.split('::').inject(Github) do |constant, klass| constant.const_get klass end end end # Factory end # Api end # Github github_api-0.18.2/lib/github_api/api/arguments.rb0000644000004100000410000001457013214644262021744 0ustar www-datawww-data# encoding: utf-8 require_relative '../normalizer' require_relative '../parameter_filter' require_relative '../params_hash' require_relative '../validations' module Github class API # A class responsible for handilng request arguments class Arguments include Normalizer include ParameterFilter include Validations AUTO_PAGINATION = 'auto_pagination'.freeze # Parameters passed to request attr_reader :params # The remaining unparsed arguments attr_reader :remaining # The request api attr_reader :api # Initialize an Arguments # # @param [Hash] options # # @option options [Array[String]] :required # arguments that must be present before request is fired # # @option options [Github::API] :api # the reference to the current api # # @api public def initialize(options = {}, &block) normalize! options @api = options.fetch('api') @required = options.fetch('required', []).map(&:to_s) @optional = options.fetch('optional', []).map(&:to_s) @assigns = {} yield_or_eval(&block) end # Specify required attribute(s) # # @api public def require(*attrs, &block) attrs_clone = attrs.clone @required = Array(attrs_clone) self end alias :required :require # Specify optional attribute(s) # # @api public def optional(*attrs, &block) end # Hash like access to request arguments # # @param [String, Symbol] property # the property name # # @api public def [](property) @assigns[property.to_s] end def []=(property, value) @assigns[property.to_s] = value end def method_missing(method_name, *args, &block) if @assigns.key?(method_name.to_s) self[method_name] else super end end def respond_to_missing?(method_name, include_private = false) @assigns.key?(method_name) || super end # Parse arguments to allow for flexible api calls # # Arguments can be part of parameters hash or be simple string arguments. # # @api public def parse(*args, &block) options = ParamsHash.new(args.extract_options!) normalize! options if args.size.zero? # Arguments are inside the parameters hash parse_hash(options) else parse_array(*args) end @params = options @remaining = args[@required.size..-1] extract_pagination(options) yield_or_eval(&block) self end # Remove unknown keys from parameters hash. # # = Parameters # :recursive - boolean that toggles whether nested filtering should be applied # def permit(keys, key=nil, options={}) filter! keys, (key.nil? ? params : params[key]), options if keys.any? self end # Check if required keys are present inside parameters hash. # # @api public def assert_required(*required) assert_required_keys(required, params) self end # Check if parameters match expected values. # # @api public def assert_values(values, key=nil) assert_valid_values values, (key.nil? ? params : params[key]) self end private # Parse array arguments and assign in order to required properties # # @param [Array[Object]] args # # @raise ArgumentError # # @return [nil] # # @api public def parse_array(*args) assert_presence_of(*args) @required.each_with_index do |req, indx| @assigns[req] = args[indx] end check_requirement!(*args) end # Remove required arguments from parameters and # validate their presence(if not nil or empty string). # # @param [Hash[String]] options # # @return [nil] # # @api private def parse_hash(options) options.each { |key, val| remove_required(options, key, val) } hash = update_required_from_global check_requirement!(*hash.keys) end # Remove required property from hash # # @param [Hash[String]] options # the options to check # # @param [String] key # the key to remove # # @param [String] val # the value to assign # # @api private def remove_required(options, key, val) if @required.include?(key.to_s) assert_presence_of(val) options.delete(key) @assigns[key.to_s] = val end end # Update required property from globals if not present # # @return [Hash[String]] # # @api private def update_required_from_global @required.reduce({}) do |hash, property| if @assigns.key?(property) hash[property] = self[property] elsif api_property?(property) hash[property] = api.send(:"#{property}") self[property] = hash[property] end hash end end # Check if api has non-empty property # # @param [String] property # the property to check # # @return [Boolean] # # @api private def api_property?(property) api.respond_to?(:"#{property}") && api.send(:"#{property}") end # Check if required arguments are present. # # def check_requirement!(*args) args_length = args.length required_length = @required.length if args_length < required_length raise ArgumentError, "Wrong number of arguments " \ "(#{args_length} for #{required_length}). " \ "Expected `#{@required.join(', ')}` as required arguments, " \ "but got `#{args.join(", ")}`." end end # Find auto_pagination parameter in options hash # def extract_pagination(options) if (value = options.delete(AUTO_PAGINATION)) api.auto_pagination = value end end # Evaluate a block # # @api privte def yield_or_eval(&block) return unless block block.arity > 0 ? yield(self) : instance_eval(&block) end end # Arguments end # Api end # Github github_api-0.18.2/lib/github_api/api/config.rb0000644000004100000410000000463013214644262021200 0ustar www-datawww-data# encoding: utf-8 require_relative 'config/property' require_relative 'config/property_set' module Github class API # A base class for constructing api configuration class Config # Defines a property on an object's class or instance # # @example # class Configuration < Api::Config # property :adapter, default: :net_http # property :user, required: true # end # # @param [Symbol] name # the name of a property # # @param [#to_hash] options # the extra options # # @return [self] # # @api public def self.property(name, options = {}) self.property_set << Property.new(name, options) update_subclasses(name, options) self end def self.update_subclasses(name, options) if defined?(@subclasses) && @subclasses @subclasses.each { |klass| klass.property(name, options) } end end # Check if property is defined # # @param [Symbol] name # the name to check # # @return [Boolean] # # @api public def self.property?(name) property_set.include?(name) end class << self attr_reader :property_set end instance_variable_set("@property_set", PropertySet.new(self)) def self.inherited(descendant) super (@subclasses ||= Set.new) << descendant descendant.instance_variable_set('@property_set', PropertySet.new(descendant, self.property_set.properties.dup)) end def initialize(&block) super(&block) end def property_names self.class.property_set.properties.map(&:name) end def self.property_names property_set.properties.map(&:name) end # Fetach all the properties and their values # # @return [Hash[Symbol]] # # @api public def fetch(value = nil) if value self.class.property_set[value] else self.class.property_set.to_hash end end # Provide access to properties # # @example # config.call do |config| # config.adapter = :net_http # end # # @return [self] # # @api private def call(&block) block.call(self) if block_given? self end end # Config end # Api end # Github github_api-0.18.2/lib/github_api/api/config/0000755000004100000410000000000013214644262020650 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/api/config/property.rb0000644000004100000410000000134113214644262023060 0ustar www-datawww-data# encoding: utf-8 module Github class API class Config # Property objects provide an interface for configuration options class Property attr_reader :name attr_reader :default attr_reader :required def initialize(name, options) @name = name @default = options.fetch(:default, nil) @required = options.fetch(:required, nil) @options = options end # @api private def define_accessor_methods(properties) properties.define_reader_method(self, self.name, :public) properties.define_writer_method(self, "#{self.name}=", :public) end end # Property end # Config end # Api end # Github github_api-0.18.2/lib/github_api/api/config/property_set.rb0000644000004100000410000000553013214644262023737 0ustar www-datawww-data# encoding: utf-8 require 'set' module Github class API class Config # Class responsible for storing configuration properties class PropertySet include Enumerable attr_reader :parent attr_reader :properties # Initialize an PropertySet # # @param [Object] parent # @param [Set] properties # # @return [undefined] # # @api private def initialize(parent = nil, properties = Set.new) @parent = parent @properties = properties @map = {} end # Iterate over properties # # @yield [property] # # @yieldparam [Property] property # # @return [self] # # @api public def each return to_enum unless block_given? @map.each { |name, property| yield property if name.is_a?(Symbol) } self end # Adds property to the set # # @example # properties_set << property # # @param [Property] property # # @return [self] # # @api public def <<(property) properties << property update_map(property.name, property.default) property.define_accessor_methods(self) self end # Access property by name # # @api public def [](name) @map[name] end alias_method :fetch, :[] # Set property value by name # # @api public def []=(name, property) update_map(name, property) end # Update map with index # # @api private def update_map(name, property) @map[name.to_sym] = @map[name.to_s.freeze] = property end # Convert properties to a hash of property names and # corresponding values # # @api public def to_hash properties.each_with_object({}) do |property, props| name = property.name props[name] = self[name] end end # Check if properties exist # # @api public def empty? @map.empty? end # @api private def define_reader_method(property, method_name, visibility) property_set = self parent.send(:define_method, method_name) { property_set[property.name] } parent.send(visibility, method_name) end # @api private def define_writer_method(property, method_name, visibility) property_set = self parent.send(:define_method, method_name) do |value| property_set[property.name]= value end parent.send(visibility, method_name) end end # PropertySet end # Config end # Api end # Github github_api-0.18.2/lib/github_api/api/actions.rb0000644000004100000410000000306413214644262021373 0ustar www-datawww-data# encoding: utf-8 module Github # Responsible for providing inspection of api methods class API # Returns all API public methods for a given class. # # @return [nil] # # @api public def self.extend_with_actions(child_class) return unless child_class.is_a?(Class) return if child_class.name.nil? # Skip anonymous classes child_class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 def self.actions self.new.actions end def actions api_methods_in(#{child_class}) + module_methods_in(#{child_class}) end RUBY_EVAL end # Finds api methods in a class # # @param [Class] klass # The klass to inspect for methods. # # @api private def api_methods_in(klass) methods = klass.send(:instance_methods, false) - [:actions] methods.sort.each_with_object([]) do |method_name, accumulator| unless method_name.to_s.include?('with') || method_name.to_s.include?('without') accumulator << method_name end accumulator end end # Finds methods included through class modules # # @param [Class] klass # The klass to inspect for methods. # # @api private def module_methods_in(klass) klass.included_modules.each_with_object([]) do |mod, accumulator| if mod.to_s =~ /#{klass}/ mod.instance_methods(false).each do |method| accumulator << method end end accumulator end end end # API end # Github github_api-0.18.2/lib/github_api/request.rb0000644000004100000410000000454213214644262020654 0ustar www-datawww-data# encoding: utf-8 require_relative 'connection' require_relative 'response_wrapper' require_relative 'request/oauth2' require_relative 'request/basic_auth' require_relative 'request/jsonize' module Github # A class responsible for dispatching http requests class Request include Connection HTTP_METHODS = [:get, :head, :post, :put, :delete, :patch] METHODS_WITH_BODIES = [:post, :put, :patch] # Return http verb # # @return [Symbol] attr_reader :action # Return url # # @return [String] attr_accessor :path # Return api this request is associated with # # @return [Github::API] attr_reader :api # Create a new Request # # @return [Github::Request] # # @api public def initialize(action, path, api) @action = action @path = path @api = api end # Performs a request # # @param [Symbol] method - The Symbol the HTTP verb # @param [String] path - String relative URL to access # @param [ParamsHash] params - ParamsHash to configure the request API # # @return [Github::ResponseWrapper] # # @api private def call(current_options, params) unless HTTP_METHODS.include?(action) raise ArgumentError, "unknown http method: #{method}" end puts "EXECUTED: #{action} - #{path} with PARAMS: #{params.request_params}" if ENV['DEBUG'] request_options = params.options connection_options = current_options.merge(request_options) conn = connection(api, connection_options) self.path = Utils::Url.normalize(self.path) if conn.path_prefix != '/' && self.path.index(conn.path_prefix) != 0 self.path = (conn.path_prefix + self.path).gsub(/\/(\/)*/, '/') end response = conn.send(action) do |request| case action.to_sym when *(HTTP_METHODS - METHODS_WITH_BODIES) request.body = params.data if params.key?('data') if params.key?('encoder') request.params.params_encoder(params.encoder) end request.url(self.path, params.request_params) when *METHODS_WITH_BODIES request.url(self.path, connection_options[:query] || {}) request.body = params.data unless params.empty? end end ResponseWrapper.new(response, api) end end # Request end # Github github_api-0.18.2/lib/github_api/page_iterator.rb0000644000004100000410000000661113214644262022010 0ustar www-datawww-data# encoding: utf-8 require 'uri' require_relative 'constants' require_relative 'paged_request' require_relative 'utils/url' module Github # A class responsible for requesting resources through page links # # @api private class PageIterator include Github::Constants include Github::Utils::Url include Github::PagedRequest # Setup attribute accesor for all the link types ATTRIBUTES = [META_FIRST, META_NEXT, META_PREV, META_LAST] DEFAULT_SHA = 'master' ATTRIBUTES.each do |attr| attr_accessor :"#{attr}_page_uri", :"#{attr}_page" end attr_reader :current_api def initialize(links, current_api) @links = links @current_api = current_api update_page_links(@links) end def next? next_page == 0 || !next_page_uri.nil? end def count parse_query(URI(last_page_uri).query)['page'] if last_page_uri end # Perform http get request for the first resource # def first perform_request(first_page_uri) if first_page_uri end # Perform http get request for the next resource # def next perform_request(next_page_uri) if next? end # Perform http get request for the previous resource # def prev perform_request(prev_page_uri) if prev_page_uri end # Perform http get request for the last resource # def last perform_request(last_page_uri) if last_page_uri end # Returns the result for a specific page. # def get_page(page_number) # Find URI that we can work with, if we cannot get the first or the # last page URI then there is only one page. page_uri = first_page_uri || last_page_uri return nil unless page_uri perform_request(page_uri, page_number) end private def perform_request(page_uri_path, page_number = nil) page_uri = URI(page_uri_path) params = parse_query(page_uri.query) if page_number params['page'] = page_number elsif next_page < 1 sha = sha(params) params['sha'] = sha if sha else params['page'] = parse_page_number(page_uri_path) end params['per_page'] = parse_per_page_number(page_uri_path) response = page_request(page_uri.path, params) update_page_links response.links response end def sha(params) return params['last_sha'] if params.keys.include?('last_sha') return DEFAULT_SHA if params.keys.include?('sha') end def parse_per_page_number(uri) # :nodoc: parse_page_params(uri, PARAM_PER_PAGE) end def parse_page_number(uri) # :nodoc: parse_page_params(uri, PARAM_PAGE) end # Extracts query string parameter for given name def parse_page_params(uri, attr) # :nodoc: return -1 if uri.nil? || uri.empty? parsed = nil begin parsed = URI.parse(uri) rescue URI::Error return -1 end param = parse_query_for_param(parsed.query, attr) return -1 if param.nil? || param.empty? begin return param.to_i rescue ArgumentError return -1 end end # Wholesale update of all link attributes def update_page_links(links) # :nodoc: ATTRIBUTES.each do |attr| send(:"#{attr}_page_uri=", links.send(:"#{attr}")) send(:"#{attr}_page=", parse_page_number(links.send(:"#{attr}"))) end end end # PageIterator end # Github github_api-0.18.2/lib/github_api/api.rb0000644000004100000410000002421113214644262017730 0ustar www-datawww-data# encoding: utf-8 require_relative 'authorization' require_relative 'api/actions' require_relative 'api/factory' require_relative 'api/arguments' require_relative 'configuration' require_relative 'constants' require_relative 'mime_type' require_relative 'null_encoder' require_relative 'rate_limit' require_relative 'request/verbs' require_relative 'validations' module Github # Core class responsible for api interface operations class API include Constants include Authorization include MimeType include RateLimit include Request::Verbs attr_reader(*Github.configuration.property_names) attr_accessor(*Validations::VALID_API_KEYS) attr_accessor :current_options # Callback to update current configuration options class_eval do Github.configuration.property_names.each do |key| define_method "#{key}=" do |arg| self.instance_variable_set("@#{key}", arg) self.current_options.merge!({:"#{key}" => arg}) end end end # Requires internal libraries # # @param [String] prefix # the relative path prefix # @param [Array[String]] libs # the array of libraries to require # # @return [self] # # @api public def self.require_all(prefix, *libs) libs.each do |lib| require "#{File.join(prefix, lib)}" end end # Create new API # # @api public def initialize(options={}, &block) opts = Github.configuration.fetch.merge(options) @current_options = opts Github.configuration.property_names.each do |key| send("#{key}=", opts[key]) end if opts.key?(:login) && !opts[:login].nil? @login, @password = opts[:login], opts[:password] elsif opts.key?(:basic_auth) && !opts[:basic_auth].nil? @login, @password = extract_basic_auth(opts[:basic_auth]) end yield_or_eval(&block) if block_given? end # Call block with argument # # @api private def yield_or_eval(&block) return unless block block.arity > 0 ? yield(self) : self.instance_eval(&block) end # Extract login and password from basic_auth parameter # # @api private def extract_basic_auth(auth) case auth when String auth.split(':', 2) when Hash [auth[:login], auth[:password]] end end # Disable following redirects inside a block # # @api public def disable_redirects self.follow_redirects = false yield ensure self.follow_redirects = true end # List of before callbacks # # @api public def self.before_callbacks @before_callbacks ||= [] end # List of after callbacks # # @api public def self.after_callbacks @after_callbacks ||= [] end # Before request filter # # @api public def self.before_request(callback, params = {}) before_callbacks << params.merge(callback: callback) end # After request filter # # @api public def self.after_request(callback, params = {}) after_callbacks << params.merge(callback: callback) end class << self attr_reader :root alias_method :root?, :root end def self.root! @root = true end def self.inherited(child_class) before_callbacks.reverse_each { |callback| child_class.before_callbacks.unshift(callback) } after_callbacks.reverse_each { |callback| child_class.after_callbacks.unshift(callback) } extend_with_actions(child_class) unless child_class.instance_variable_defined?(:@root) child_class.instance_variable_set(:@root, false) end super end root! def self.internal_methods api = self api = api.superclass until api.root? api.public_instance_methods(true) end def self.extra_methods ['actions'] end # Find all the api methods that should be considred by # request callbacks. # # @return [Set] # # @api private def self.request_methods @request_methods ||= begin methods = (public_instance_methods(true) - internal_methods + public_instance_methods(false)).uniq.map(&:to_s) Set.new(methods - extra_methods) end end def self.clear_request_methods! @request_methods = nil end def self.method_added(method_name) method_name = method_name.to_s.gsub(/_with(out)?_callback_.*$/, '') # Only subclasses matter return if self.root? return if extra_methods.include?(method_name) # Only public methods are of interest return unless request_methods.include?(method_name) # Do not redefine return if (@__methods_added ||= []).include?(method_name) class_name = self.name.to_s.split('::').last.downcase with_method = "#{method_name}_with_callback_#{class_name}" without_method = "#{method_name}_without_callback_#{class_name}" return if public_method_defined?(with_method) [method_name, with_method, without_method].each do |met| @__methods_added << met end return if public_method_defined?(with_method) define_method(with_method) do |*args, &block| send(:execute, without_method, *args, &block) end alias_method without_method, method_name alias_method method_name, with_method clear_request_methods! end # Filter callbacks based on kind # # @param [Symbol] kind # one of :before or :after # # @return [Array[Hash]] # # @api private def filter_callbacks(kind, action_name) self.class.send("#{kind}_callbacks").select do |callback| callback[:only].nil? || callback[:only].include?(action_name) end end # Run all callbacks associated with this action # # @apram [Symbol] action_name # # @api private def run_callbacks(action_name, &block) filter_callbacks(:before, action_name).each { |hook| send hook[:callback] } yield if block_given? filter_callbacks(:after, action_name).each { |hook| send hook[:callback] } end # Execute action # # @param [Symbol] action # # @api private def execute(action, *args, &block) action_name = action.to_s.gsub(/_with(out)?_callback_.*$/, '') result = nil run_callbacks(action_name) do result = send(action, *args, &block) end result end # Responds to attribute query or attribute clear # # @api private def method_missing(method_name, *args, &block) # :nodoc: case method_name.to_s when /^(.*)\?$/ return !!send($1.to_s) when /^clear_(.*)$/ send("#{$1.to_s}=", nil) else super end end def respond_to?(method_name, include_private = false) method_name.to_s.start_with?('clear_') || super end # Acts as setter and getter for api requests arguments parsing. # # Returns Arguments instance. # def arguments(args=(not_set = true), options={}, &block) if not_set @arguments else @arguments = Arguments.new(options.merge!(api: self)).parse(*args, &block) end end # Set a configuration option for a given namespace # # @param [String] option # @param [Object] value # @param [Boolean] ignore_setter # # @return [self] # # @api public def set(option, value=(not_set=true), ignore_setter=false, &block) raise ArgumentError, 'value not set' if block and !not_set return self if !not_set and value.nil? if not_set set_options option return self end if respond_to?("#{option}=") and not ignore_setter return __send__("#{option}=", value) end define_accessors option, value self end # Defines a namespace # # @param [Array[Symbol]] names # the name for the scope # # @example # namespace :scopes # # @return [self] # # @api public def self.namespace(*names) options = names.last.is_a?(Hash) ? names.pop : {} names = names.map(&:to_sym) name = names.pop if public_method_defined?(name) raise ArgumentError, "namespace '#{name}' is already defined" end class_name = extract_class_name(name, options) define_method(name) do |*args, &block| options = args.last.is_a?(Hash) ? args.pop : {} API::Factory.new(class_name, current_options.merge(options), &block) end end # Extracts class name from options # # @param [Hash] options # @option options [String] :full_name # the full name for the class # @option options [Boolean] :root # if the class is at the root or not # # @example # extract_class_name(:stats, class_name: :statistics) # # @return [String] # # @api private def self.extract_class_name(name, options) converted = options.fetch(:full_name, name).to_s converted = converted.split('_').map(&:capitalize).join class_name = options.fetch(:root, false) ? '': "#{self.name}::" class_name += converted class_name end private # Set multiple options # # @api private def set_options(options) unless options.respond_to?(:each) raise ArgumentError, 'cannot iterate over value' end options.each { |key, value| set(key, value) } end # Define setters and getters # # @api private def define_accessors(option, value) setter = proc { |val| set option, val, true } getter = proc { value } define_singleton_method("#{option}=", setter) if setter define_singleton_method(option, getter) if getter end # Dynamically define a method for setting request option # # @api private def define_singleton_method(method_name, content=Proc.new) (class << self; self; end).class_eval do undef_method(method_name) if method_defined?(method_name) if String === content class_eval("def #{method_name}() #{content}; end") else define_method(method_name, &content) end end end end # API end # Github github_api-0.18.2/lib/github_api/ssl_certs/0000755000004100000410000000000013214644262020633 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/ssl_certs/cacerts.pem0000644000004100000410000040731613214644262022775 0ustar www-datawww-data# Issuer: CN=GTE CyberTrust Global Root O=GTE Corporation OU=GTE CyberTrust Solutions, Inc. # Subject: CN=GTE CyberTrust Global Root O=GTE Corporation OU=GTE CyberTrust Solutions, Inc. # Label: "GTE CyberTrust Global Root" # Serial: 421 # MD5 Fingerprint: ca:3d:d3:68:f1:03:5c:d0:32:fa:b8:2b:59:e8:5a:db # SHA1 Fingerprint: 97:81:79:50:d8:1c:96:70:cc:34:d8:09:cf:79:44:31:36:7e:f4:74 # SHA256 Fingerprint: a5:31:25:18:8d:21:10:aa:96:4b:02:c7:b7:c6:da:32:03:17:08:94:e5:fb:71:ff:fb:66:67:d5:e6:81:0a:36 -----BEGIN CERTIFICATE----- MIICWjCCAcMCAgGlMA0GCSqGSIb3DQEBBAUAMHUxCzAJBgNVBAYTAlVTMRgwFgYD VQQKEw9HVEUgQ29ycG9yYXRpb24xJzAlBgNVBAsTHkdURSBDeWJlclRydXN0IFNv bHV0aW9ucywgSW5jLjEjMCEGA1UEAxMaR1RFIEN5YmVyVHJ1c3QgR2xvYmFsIFJv b3QwHhcNOTgwODEzMDAyOTAwWhcNMTgwODEzMjM1OTAwWjB1MQswCQYDVQQGEwJV UzEYMBYGA1UEChMPR1RFIENvcnBvcmF0aW9uMScwJQYDVQQLEx5HVEUgQ3liZXJU cnVzdCBTb2x1dGlvbnMsIEluYy4xIzAhBgNVBAMTGkdURSBDeWJlclRydXN0IEds b2JhbCBSb290MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVD6C28FCc6HrH iM3dFw4usJTQGz0O9pTAipTHBsiQl8i4ZBp6fmw8U+E3KHNgf7KXUwefU/ltWJTS r41tiGeA5u2ylc9yMcqlHHK6XALnZELn+aks1joNrI1CqiQBOeacPwGFVw1Yh0X4 04Wqk2kmhXBIgD8SFcd5tB8FLztimQIDAQABMA0GCSqGSIb3DQEBBAUAA4GBAG3r GwnpXtlR22ciYaQqPEh346B8pt5zohQDhT37qw4wxYMWM4ETCJ57NE7fQMh017l9 3PR2VX2bY1QY6fDq81yx2YtCHrnAlU66+tXifPVoYb+O7AWXX1uw16OFNMQkpw0P lZPvy5TYnh+dXIVtx6quTx8itc2VrbqnzPmrC3p/ -----END CERTIFICATE----- # Issuer: CN=Thawte Server CA O=Thawte Consulting cc OU=Certification Services Division # Subject: CN=Thawte Server CA O=Thawte Consulting cc OU=Certification Services Division # Label: "Thawte Server CA" # Serial: 1 # MD5 Fingerprint: c5:70:c4:a2:ed:53:78:0c:c8:10:53:81:64:cb:d0:1d # SHA1 Fingerprint: 23:e5:94:94:51:95:f2:41:48:03:b4:d5:64:d2:a3:a3:f5:d8:8b:8c # SHA256 Fingerprint: b4:41:0b:73:e2:e6:ea:ca:47:fb:c4:2f:8f:a4:01:8a:f4:38:1d:c5:4c:fa:a8:44:50:46:1e:ed:09:45:4d:e9 -----BEGIN CERTIFICATE----- MIIDEzCCAnygAwIBAgIBATANBgkqhkiG9w0BAQQFADCBxDELMAkGA1UEBhMCWkEx FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv biBTZXJ2aWNlcyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEm MCQGCSqGSIb3DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wHhcNOTYwODAx MDAwMDAwWhcNMjAxMjMxMjM1OTU5WjCBxDELMAkGA1UEBhMCWkExFTATBgNVBAgT DFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYDVQQKExRUaGF3 dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNl cyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEmMCQGCSqGSIb3 DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQAD gY0AMIGJAoGBANOkUG7I/1Zr5s9dtuoMaHVHoqrC2oQl/Kj0R1HahbUgdJSGHg91 yekIYfUGbTBuFRkC6VLAYttNmZ7iagxEOM3+vuNkCXDF/rFrKbYvScg71CcEJRCX L+eQbcAoQpnXTEPew/UhbVSfXcNY4cDk2VuwuNy0e982OsK1ZiIS1ocNAgMBAAGj EzARMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEEBQADgYEAB/pMaVz7lcxG 7oWDTSEwjsrZqG9JGubaUeNgcGyEYRGhGshIPllDfU+VPaGLtwtimHp1it2ITk6e QNuozDJ0uW8NxuOzRAvZim+aKZuZGCg70eNAKJpaPNW15yAbi8qkq43pUdniTCxZ qdq5snUb9kLy78fyGPmJvKP/iiMucEc= -----END CERTIFICATE----- # Issuer: CN=Thawte Premium Server CA O=Thawte Consulting cc OU=Certification Services Division # Subject: CN=Thawte Premium Server CA O=Thawte Consulting cc OU=Certification Services Division # Label: "Thawte Premium Server CA" # Serial: 1 # MD5 Fingerprint: 06:9f:69:79:16:66:90:02:1b:8c:8c:a2:c3:07:6f:3a # SHA1 Fingerprint: 62:7f:8d:78:27:65:63:99:d2:7d:7f:90:44:c9:fe:b3:f3:3e:fa:9a # SHA256 Fingerprint: ab:70:36:36:5c:71:54:aa:29:c2:c2:9f:5d:41:91:16:3b:16:2a:22:25:01:13:57:d5:6d:07:ff:a7:bc:1f:72 -----BEGIN CERTIFICATE----- MIIDJzCCApCgAwIBAgIBATANBgkqhkiG9w0BAQQFADCBzjELMAkGA1UEBhMCWkEx FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv biBTZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UEAxMYVGhhd3RlIFByZW1pdW0gU2Vy dmVyIENBMSgwJgYJKoZIhvcNAQkBFhlwcmVtaXVtLXNlcnZlckB0aGF3dGUuY29t MB4XDTk2MDgwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgc4xCzAJBgNVBAYTAlpB MRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEdMBsG A1UEChMUVGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNVBAsTH0NlcnRpZmljYXRp b24gU2VydmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQcmVtaXVtIFNl cnZlciBDQTEoMCYGCSqGSIb3DQEJARYZcHJlbWl1bS1zZXJ2ZXJAdGhhd3RlLmNv bTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0jY2aovXwlue2oFBYo847kkE VdbQ7xwblRZH7xhINTpS9CtqBo87L+pW46+GjZ4X9560ZXUCTe/LCaIhUdib0GfQ ug2SBhRz1JPLlyoAnFxODLz6FVL88kRu2hFKbgifLy3j+ao6hnO2RlNYyIkFvYMR uHM/qgeN9EJN50CdHDcCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG 9w0BAQQFAAOBgQAmSCwWwlj66BZ0DKqqX1Q/8tfJeGBeXm43YyJ3Nn6yF8Q0ufUI hfzJATj/Tb7yFkJD57taRvvBxhEf8UqwKEbJw8RCfbz6q1lu1bdRiBHjpIUZa4JM pAwSremkrj/xw0llmozFyD4lt5SZu5IycQfwhl7tUCemDaYj+bvLpgcUQg== -----END CERTIFICATE----- # Issuer: O=Equifax OU=Equifax Secure Certificate Authority # Subject: O=Equifax OU=Equifax Secure Certificate Authority # Label: "Equifax Secure CA" # Serial: 903804111 # MD5 Fingerprint: 67:cb:9d:c0:13:24:8a:82:9b:b2:17:1e:d1:1b:ec:d4 # SHA1 Fingerprint: d2:32:09:ad:23:d3:14:23:21:74:e4:0d:7f:9d:62:13:97:86:63:3a # SHA256 Fingerprint: 08:29:7a:40:47:db:a2:36:80:c7:31:db:6e:31:76:53:ca:78:48:e1:be:bd:3a:0b:01:79:a7:07:f9:2c:f1:78 -----BEGIN CERTIFICATE----- MIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV UzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2Vy dGlmaWNhdGUgQXV0aG9yaXR5MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1 MVowTjELMAkGA1UEBhMCVVMxEDAOBgNVBAoTB0VxdWlmYXgxLTArBgNVBAsTJEVx dWlmYXggU2VjdXJlIENlcnRpZmljYXRlIEF1dGhvcml0eTCBnzANBgkqhkiG9w0B AQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPRfM6f BeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+A cJkVV5MW8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kC AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQ MA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlm aWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTgw ODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvSspXXR9gj IBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQF MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA A4GBAFjOKer89961zgK5F7WF0bnj4JXMJTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y 7qj/WsjTVbJmcVfewCHrPSqnI0kBBIZCe/zuf6IWUrVnZ9NA2zsmWLIodz2uFHdh 1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee9570+sB3c4 -----END CERTIFICATE----- # Issuer: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority # Subject: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority # Label: "Verisign Class 3 Public Primary Certification Authority" # Serial: 149843929435818692848040365716851702463 # MD5 Fingerprint: 10:fc:63:5d:f6:26:3e:0d:f3:25:be:5f:79:cd:67:67 # SHA1 Fingerprint: 74:2c:31:92:e6:07:e4:24:eb:45:49:54:2b:e1:bb:c5:3e:61:74:e2 # SHA256 Fingerprint: e7:68:56:34:ef:ac:f6:9a:ce:93:9a:6b:25:5b:7b:4f:ab:ef:42:93:5b:50:a2:65:ac:b5:cb:60:27:e4:4e:70 -----BEGIN CERTIFICATE----- MIICPDCCAaUCEHC65B0Q2Sk0tjjKewPMur8wDQYJKoZIhvcNAQECBQAwXzELMAkG A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2 MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G CSqGSIb3DQEBAgUAA4GBALtMEivPLCYATxQT3ab7/AoRhIzzKBxnki98tsX63/Do lbwdj2wsqFHMc9ikwFPwTtYmwHYBV4GSXiHx0bH/59AhWM1pF+NEHJwZRDmJXNyc AA9WjQKZ7aKQRUzkuxCkPfAyAw7xzvjoyVGM5mKf5p/AfbdynMk2OmufTqj/ZA1k -----END CERTIFICATE----- # Issuer: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority - G2/(c) 1998 VeriSign, Inc. - For authorized use only/VeriSign Trust Network # Subject: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority - G2/(c) 1998 VeriSign, Inc. - For authorized use only/VeriSign Trust Network # Label: "Verisign Class 3 Public Primary Certification Authority - G2" # Serial: 167285380242319648451154478808036881606 # MD5 Fingerprint: a2:33:9b:4c:74:78:73:d4:6c:e7:c1:f3:8d:cb:5c:e9 # SHA1 Fingerprint: 85:37:1c:a6:e5:50:14:3d:ce:28:03:47:1b:de:3a:09:e8:f8:77:0f # SHA256 Fingerprint: 83:ce:3c:12:29:68:8a:59:3d:48:5f:81:97:3c:0f:91:95:43:1e:da:37:cc:5e:36:43:0e:79:c7:a8:88:63:8b -----BEGIN CERTIFICATE----- MIIDAjCCAmsCEH3Z/gfPqB63EHln+6eJNMYwDQYJKoZIhvcNAQEFBQAwgcExCzAJ BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh c3MgMyBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMyBQdWJsaWMg UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5 MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB AQUAA4GNADCBiQKBgQDMXtERXVxp0KvTuWpMmR9ZmDCOFoUgRm1HP9SFIIThbbP4 pO0M8RcPO/mn+SXXwc+EY/J8Y8+iR/LGWzOOZEAEaMGAuWQcRXfH2G71lSk8UOg0 13gfqLptQ5GVj0VXXn7F+8qkBOvqlzdUMG+7AUcyM83cV5tkaWH4mx0ciU9cZwID AQABMA0GCSqGSIb3DQEBBQUAA4GBAFFNzb5cy5gZnBWyATl4Lk0PZ3BwmcYQWpSk U01UbSuvDV1Ai2TT1+7eVmGSX6bEHRBhNtMsJzzoKQm5EWR0zLVznxxIqbxhAe7i F6YM40AIOw7n60RzKprxaZLvcRTDOaxxp5EJb+RxBrO6WVcmeQD2+A2iMzAo1KpY oJ2daZH9 -----END CERTIFICATE----- # Issuer: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA # Subject: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA # Label: "GlobalSign Root CA" # Serial: 4835703278459707669005204 # MD5 Fingerprint: 3e:45:52:15:09:51:92:e1:b7:5d:37:9f:b1:87:29:8a # SHA1 Fingerprint: b1:bc:96:8b:d4:f4:9d:62:2a:a8:9a:81:f2:15:01:52:a4:1d:82:9c # SHA256 Fingerprint: eb:d4:10:40:e4:bb:3e:c7:42:c9:e3:81:d3:1e:f2:a4:1a:48:b6:68:5c:96:e7:ce:f3:c1:df:6c:d4:33:1c:99 -----BEGIN CERTIFICATE----- MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp 1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8 9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE 38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A== -----END CERTIFICATE----- # Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2 # Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2 # Label: "GlobalSign Root CA - R2" # Serial: 4835703278459682885658125 # MD5 Fingerprint: 94:14:77:7e:3e:5e:fd:8f:30:bd:41:b0:cf:e7:d0:30 # SHA1 Fingerprint: 75:e0:ab:b6:13:85:12:27:1c:04:f8:5f:dd:de:38:e4:b7:24:2e:fe # SHA256 Fingerprint: ca:42:dd:41:74:5f:d0:b8:1e:b9:02:36:2c:f9:d8:bf:71:9d:a1:bd:1b:1e:fc:94:6f:5b:4c:99:f4:2c:1b:9e -----BEGIN CERTIFICATE----- MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1 MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8 eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG 3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO 291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7 TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg== -----END CERTIFICATE----- # Issuer: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 1 Policy Validation Authority # Subject: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 1 Policy Validation Authority # Label: "ValiCert Class 1 VA" # Serial: 1 # MD5 Fingerprint: 65:58:ab:15:ad:57:6c:1e:a8:a7:b5:69:ac:bf:ff:eb # SHA1 Fingerprint: e5:df:74:3c:b6:01:c4:9b:98:43:dc:ab:8c:e8:6a:81:10:9f:e4:8e # SHA256 Fingerprint: f4:c1:49:55:1a:30:13:a3:5b:c7:bf:fe:17:a7:f3:44:9b:c1:ab:5b:5a:0a:e7:4b:06:c2:3b:90:00:4c:01:04 -----BEGIN CERTIFICATE----- MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG 9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNTIyMjM0OFoXDTE5MDYy NTIyMjM0OFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs YXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDYWYJ6ibiWuqYvaG9Y LqdUHAZu9OqNSLwxlBfw8068srg1knaw0KWlAdcAAxIiGQj4/xEjm84H9b9pGib+ TunRf50sQB1ZaG6m+FiwnRqP0z/x3BkGgagO4DrdyFNFCQbmD3DD+kCmDuJWBQ8Y TfwggtFzVXSNdnKgHZ0dwN0/cQIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFBoPUn0 LBwGlN+VYH+Wexf+T3GtZMjdd9LvWVXoP+iOBSoh8gfStadS/pyxtuJbdxdA6nLW I8sogTLDAHkY7FkXicnGah5xyf23dKUlRWnFSKsZ4UWKJWsZ7uW7EvV/96aNUcPw nXS3qT6gpf+2SQMT2iLM7XGCK5nPOrf1LXLI -----END CERTIFICATE----- # Issuer: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 2 Policy Validation Authority # Subject: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 2 Policy Validation Authority # Label: "ValiCert Class 2 VA" # Serial: 1 # MD5 Fingerprint: a9:23:75:9b:ba:49:36:6e:31:c2:db:f2:e7:66:ba:87 # SHA1 Fingerprint: 31:7a:2a:d0:7f:2b:33:5e:f5:a1:c3:4e:4b:57:e8:b7:d8:f1:fc:a6 # SHA256 Fingerprint: 58:d0:17:27:9c:d4:dc:63:ab:dd:b1:96:a6:c9:90:6c:30:c4:e0:87:83:ea:e8:c1:60:99:54:d6:93:55:59:6b -----BEGIN CERTIFICATE----- MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG 9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMTk1NFoXDTE5MDYy NjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOOnHK5avIWZJV16vY dA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVCCSRrCl6zfN1SLUzm1NZ9 WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7RfZHM047QS v4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9v UJSZSWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTu IYEZoDJJKPTEjlbVUjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwC W/POuZ6lcg5Ktz885hZo+L7tdEy8W9ViH0Pd -----END CERTIFICATE----- # Issuer: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 3 Policy Validation Authority # Subject: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 3 Policy Validation Authority # Label: "RSA Root Certificate 1" # Serial: 1 # MD5 Fingerprint: a2:6f:53:b7:ee:40:db:4a:68:e7:fa:18:d9:10:4b:72 # SHA1 Fingerprint: 69:bd:8c:f4:9c:d3:00:fb:59:2e:17:93:ca:55:6a:f3:ec:aa:35:fb # SHA256 Fingerprint: bc:23:f9:8a:31:3c:b9:2d:e3:bb:fc:3a:5a:9f:44:61:ac:39:49:4c:4a:e1:5a:9e:9d:f1:31:e9:9b:73:01:9a -----BEGIN CERTIFICATE----- MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG 9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMjIzM1oXDTE5MDYy NjAwMjIzM1owgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs YXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDjmFGWHOjVsQaBalfD cnWTq8+epvzzFlLWLU2fNUSoLgRNB0mKOCn1dzfnt6td3zZxFJmP3MKS8edgkpfs 2Ejcv8ECIMYkpChMMFp2bbFc893enhBxoYjHW5tBbcqwuI4V7q0zK89HBFx1cQqY JJgpp0lZpd34t0NiYfPT4tBVPwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFa7AliE Zwgs3x/be0kz9dNnnfS0ChCzycUs4pJqcXgn8nCDQtM+z6lU9PHYkhaM0QTLS6vJ n0WuPIqpsHEzXcjFV9+vqDWzf4mH6eglkrh/hXqu1rweN1gqZ8mRzyqBPu3GOd/A PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu -----END CERTIFICATE----- # Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only # Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only # Label: "Verisign Class 3 Public Primary Certification Authority - G3" # Serial: 206684696279472310254277870180966723415 # MD5 Fingerprint: cd:68:b6:a7:c7:c4:ce:75:e0:1d:4f:57:44:61:92:09 # SHA1 Fingerprint: 13:2d:0d:45:53:4b:69:97:cd:b2:d5:c3:39:e2:55:76:60:9b:5c:c6 # SHA256 Fingerprint: eb:04:cf:5e:b1:f3:9a:fa:76:2f:2b:b1:20:f2:96:cb:a5:20:c1:b9:7d:b1:58:95:65:b8:1c:b9:a1:7b:72:44 -----BEGIN CERTIFICATE----- MIIEGjCCAwICEQCbfgZJoz5iudXukEhxKe9XMA0GCSqGSIb3DQEBBQUAMIHKMQsw CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu IENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMu6nFL8eB8aHm8b N3O9+MlrlBIwT/A2R/XQkQr1F8ilYcEWQE37imGQ5XYgwREGfassbqb1EUGO+i2t KmFZpGcmTNDovFJbcCAEWNF6yaRpvIMXZK0Fi7zQWM6NjPXr8EJJC52XJ2cybuGu kxUccLwgTS8Y3pKI6GyFVxEa6X7jJhFUokWWVYPKMIno3Nij7SqAP395ZVc+FSBm CC+Vk7+qRy+oRpfwEuL+wgorUeZ25rdGt+INpsyow0xZVYnm6FNcHOqd8GIWC6fJ Xwzw3sJ2zq/3avL6QaaiMxTJ5Xpj055iN9WFZZ4O5lMkdBteHRJTW8cs54NJOxWu imi5V5cCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAERSWwauSCPc/L8my/uRan2Te 2yFPhpk0djZX3dAVL8WtfxUfN2JzPtTnX84XA9s1+ivbrmAJXx5fj267Cz3qWhMe DGBvtcC1IyIuBwvLqXTLR7sdwdela8wv0kL9Sd2nic9TutoAWii/gt/4uhMdUIaC /Y4wjylGsB49Ndo4YhYYSq3mtlFs3q9i6wHQHiT+eo8SGhJouPtmmRQURVyu565p F4ErWjfJXir0xuKhXFSbplQAz/DxwceYMBo7Nhbbo27q/a2ywtrvAkcTisDxszGt TxzhT5yvDwyd93gN2PQ1VoDat20Xj50egWTh/sVFuq1ruQp6Tk9LhO5L8X3dEQ== -----END CERTIFICATE----- # Issuer: CN=VeriSign Class 4 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only # Subject: CN=VeriSign Class 4 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only # Label: "Verisign Class 4 Public Primary Certification Authority - G3" # Serial: 314531972711909413743075096039378935511 # MD5 Fingerprint: db:c8:f2:27:2e:b1:ea:6a:29:23:5d:fe:56:3e:33:df # SHA1 Fingerprint: c8:ec:8c:87:92:69:cb:4b:ab:39:e9:8d:7e:57:67:f3:14:95:73:9d # SHA256 Fingerprint: e3:89:36:0d:0f:db:ae:b3:d2:50:58:4b:47:30:31:4e:22:2f:39:c1:56:a0:20:14:4e:8d:96:05:61:79:15:06 -----BEGIN CERTIFICATE----- MIIEGjCCAwICEQDsoKeLbnVqAc/EfMwvlF7XMA0GCSqGSIb3DQEBBQUAMIHKMQsw CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT aWduIENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu IENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK3LpRFpxlmr8Y+1 GQ9Wzsy1HyDkniYlS+BzZYlZ3tCD5PUPtbut8XzoIfzk6AzufEUiGXaStBO3IFsJ +mGuqPKljYXCKtbeZjbSmwL0qJJgfJxptI8kHtCGUvYynEFYHiK9zUVilQhu0Gbd U6LM8BDcVHOLBKFGMzNcF0C5nk3T875Vg+ixiY5afJqWIpA7iCXy0lOIAgwLePLm NxdLMEYH5IBtptiWLugs+BGzOA1mppvqySNb247i8xOOGlktqgLw7KSHZtzBP/XY ufTsgsbSPZUd5cBPhMnZo0QoBmrXRazwa2rvTl/4EYIeOGM0ZlDUPpNz+jDDZq3/ ky2X7wMCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAj/ola09b5KROJ1WrIhVZPMq1 CtRK26vdoV9TxaBXOcLORyu+OshWv8LZJxA6sQU8wHcxuzrTBXttmhwwjIDLk5Mq g6sFUYICABFna/OIYUdfA5PVWw3g8dShMjWFsjrbsIKr0csKvE+MW8VLADsfKoKm fjaF3H48ZwC15DtS4KjrXRX5xm3wrR0OhbepmnMUWluPQSjA1egtTaRezarZ7c7c 2NU8Qh0XwRJdRTjDOPP8hS6DRkiy1yBfkjaP53kPmF6Z6PDQpLv1U70qzlmwr25/ bLvSHgCwIe34QWKCudiyxLtGUPMxxY8BqHTr9Xgn2uf3ZkPznoM+IKrDNWCRzg== -----END CERTIFICATE----- # Issuer: CN=Entrust.net Secure Server Certification Authority O=Entrust.net OU=www.entrust.net/CPS incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited # Subject: CN=Entrust.net Secure Server Certification Authority O=Entrust.net OU=www.entrust.net/CPS incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited # Label: "Entrust.net Secure Server CA" # Serial: 927650371 # MD5 Fingerprint: df:f2:80:73:cc:f1:e6:61:73:fc:f5:42:e9:c5:7c:ee # SHA1 Fingerprint: 99:a6:9b:e6:1a:fe:88:6b:4d:2b:82:00:7c:b8:54:fc:31:7e:15:39 # SHA256 Fingerprint: 62:f2:40:27:8c:56:4c:4d:d8:bf:7d:9d:4f:6f:36:6e:a8:94:d2:2f:5f:34:d9:89:a9:83:ac:ec:2f:ff:ed:50 -----BEGIN CERTIFICATE----- MIIE2DCCBEGgAwIBAgIEN0rSQzANBgkqhkiG9w0BAQUFADCBwzELMAkGA1UEBhMC VVMxFDASBgNVBAoTC0VudHJ1c3QubmV0MTswOQYDVQQLEzJ3d3cuZW50cnVzdC5u ZXQvQ1BTIGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxpYWIuKTElMCMGA1UECxMc KGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDE6MDgGA1UEAxMxRW50cnVzdC5u ZXQgU2VjdXJlIFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05OTA1 MjUxNjA5NDBaFw0xOTA1MjUxNjM5NDBaMIHDMQswCQYDVQQGEwJVUzEUMBIGA1UE ChMLRW50cnVzdC5uZXQxOzA5BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5j b3JwLiBieSByZWYuIChsaW1pdHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBF bnRydXN0Lm5ldCBMaW1pdGVkMTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUg U2VydmVyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGdMA0GCSqGSIb3DQEBAQUA A4GLADCBhwKBgQDNKIM0VBuJ8w+vN5Ex/68xYMmo6LIQaO2f55M28Qpku0f1BBc/ I0dNxScZgSYMVHINiC3ZH5oSn7yzcdOAGT9HZnuMNSjSuQrfJNqc1lB5gXpa0zf3 wkrYKZImZNHkmGw6AIr1NJtl+O3jEP/9uElY3KDegjlrgbEWGWG5VLbmQwIBA6OC AdcwggHTMBEGCWCGSAGG+EIBAQQEAwIABzCCARkGA1UdHwSCARAwggEMMIHeoIHb oIHYpIHVMIHSMQswCQYDVQQGEwJVUzEUMBIGA1UEChMLRW50cnVzdC5uZXQxOzA5 BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5jb3JwLiBieSByZWYuIChsaW1p dHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBFbnRydXN0Lm5ldCBMaW1pdGVk MTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUgU2VydmVyIENlcnRpZmljYXRp b24gQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMCmgJ6AlhiNodHRwOi8vd3d3LmVu dHJ1c3QubmV0L0NSTC9uZXQxLmNybDArBgNVHRAEJDAigA8xOTk5MDUyNTE2MDk0 MFqBDzIwMTkwNTI1MTYwOTQwWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAU8Bdi E1U9s/8KAGv7UISX8+1i0BowHQYDVR0OBBYEFPAXYhNVPbP/CgBr+1CEl/PtYtAa MAwGA1UdEwQFMAMBAf8wGQYJKoZIhvZ9B0EABAwwChsEVjQuMAMCBJAwDQYJKoZI hvcNAQEFBQADgYEAkNwwAvpkdMKnCqV8IY00F6j7Rw7/JXyNEwr75Ji174z4xRAN 95K+8cPV1ZVqBLssziY2ZcgxxufuP+NXdYR6Ee9GTxj005i7qIcyunL2POI9n9cd 2cNgQ4xYDiKWL2KjLB+6rQXvqzJ4h6BUcxm1XAX5Uj5tLUUL9wqT6u0G+bI= -----END CERTIFICATE----- # Issuer: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited # Subject: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited # Label: "Entrust.net Premium 2048 Secure Server CA" # Serial: 946059622 # MD5 Fingerprint: ba:21:ea:20:d6:dd:db:8f:c1:57:8b:40:ad:a1:fc:fc # SHA1 Fingerprint: 80:1d:62:d0:7b:44:9d:5c:5c:03:5c:98:ea:61:fa:44:3c:2a:58:fe # SHA256 Fingerprint: d1:c3:39:ea:27:84:eb:87:0f:93:4f:c5:63:4e:4a:a9:ad:55:05:01:64:01:f2:64:65:d3:7a:57:46:63:35:9f -----BEGIN CERTIFICATE----- MIIEXDCCA0SgAwIBAgIEOGO5ZjANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5 IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0xOTEy MjQxODIwNTFaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3 LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/ HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH 4QIDAQABo3QwcjARBglghkgBhvhCAQEEBAMCAAcwHwYDVR0jBBgwFoAUVeSB0RGA vtiJuQijMfmhJAkWuXAwHQYDVR0OBBYEFFXkgdERgL7YibkIozH5oSQJFrlwMB0G CSqGSIb2fQdBAAQQMA4bCFY1LjA6NC4wAwIEkDANBgkqhkiG9w0BAQUFAAOCAQEA WUesIYSKF8mciVMeuoCFGsY8Tj6xnLZ8xpJdGGQC49MGCBFhfGPjK50xA3B20qMo oPS7mmNz7W3lKtvtFKkrxjYR0CvrB4ul2p5cGZ1WEvVUKcgF7bISKo30Axv/55IQ h7A6tcOdBTcSo8f0FbnVpDkWm1M6I5HxqIKiaohowXkCIryqptau37AUX7iH0N18 f3v/rxzP5tsHrV7bhZ3QKw0z2wTR5klAEyt2+z7pnIkPFc4YsIV4IU9rTw76NmfN B/L/CNDi3tm/Kq+4h4YhPATKt5Rof8886ZjXOP/swNlQ8C5LWK5Gb9Auw2DaclVy vUxFnmG6v4SBkgPR0ml8xQ== -----END CERTIFICATE----- # Issuer: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust # Subject: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust # Label: "Baltimore CyberTrust Root" # Serial: 33554617 # MD5 Fingerprint: ac:b6:94:a5:9c:17:e0:d7:91:52:9b:b1:97:06:a6:e4 # SHA1 Fingerprint: d4:de:20:d0:5e:66:fc:53:fe:1a:50:88:2c:78:db:28:52:ca:e4:74 # SHA256 Fingerprint: 16:af:57:a9:f6:76:b0:ab:12:60:95:aa:5e:ba:de:f2:2a:b3:11:19:d6:44:ac:95:cd:4b:93:db:f3:f2:6a:eb -----BEGIN CERTIFICATE----- MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1 BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3 DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92 9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0 Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp -----END CERTIFICATE----- # Issuer: CN=Equifax Secure Global eBusiness CA-1 O=Equifax Secure Inc. # Subject: CN=Equifax Secure Global eBusiness CA-1 O=Equifax Secure Inc. # Label: "Equifax Secure Global eBusiness CA" # Serial: 1 # MD5 Fingerprint: 8f:5d:77:06:27:c4:98:3c:5b:93:78:e7:d7:7d:9b:cc # SHA1 Fingerprint: 7e:78:4a:10:1c:82:65:cc:2d:e1:f1:6d:47:b4:40:ca:d9:0a:19:45 # SHA256 Fingerprint: 5f:0b:62:ea:b5:e3:53:ea:65:21:65:16:58:fb:b6:53:59:f4:43:28:0a:4a:fb:d1:04:d7:7d:10:f9:f0:4c:07 -----BEGIN CERTIFICATE----- MIICkDCCAfmgAwIBAgIBATANBgkqhkiG9w0BAQQFADBaMQswCQYDVQQGEwJVUzEc MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEtMCsGA1UEAxMkRXF1aWZheCBT ZWN1cmUgR2xvYmFsIGVCdXNpbmVzcyBDQS0xMB4XDTk5MDYyMTA0MDAwMFoXDTIw MDYyMTA0MDAwMFowWjELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0VxdWlmYXggU2Vj dXJlIEluYy4xLTArBgNVBAMTJEVxdWlmYXggU2VjdXJlIEdsb2JhbCBlQnVzaW5l c3MgQ0EtMTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAuucXkAJlsTRVPEnC UdXfp9E3j9HngXNBUmCbnaEXJnitx7HoJpQytd4zjTov2/KaelpzmKNc6fuKcxtc 58O/gGzNqfTWK8D3+ZmqY6KxRwIP1ORROhI8bIpaVIRw28HFkM9yRcuoWcDNM50/ o5brhTMhHD4ePmBudpxnhcXIw2ECAwEAAaNmMGQwEQYJYIZIAYb4QgEBBAQDAgAH MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUvqigdHJQa0S3ySPY+6j/s1dr aGwwHQYDVR0OBBYEFL6ooHRyUGtEt8kj2Puo/7NXa2hsMA0GCSqGSIb3DQEBBAUA A4GBADDiAVGqx+pf2rnQZQ8w1j7aDRRJbpGTJxQx78T3LUX47Me/okENI7SS+RkA Z70Br83gcfxaz2TE4JaY0KNA4gGK7ycH8WUBikQtBmV1UsCGECAhX2xrD2yuCRyv 8qIYNMR1pHMc8Y3c7635s3a0kr/clRAevsvIO1qEYBlWlKlV -----END CERTIFICATE----- # Issuer: CN=Equifax Secure eBusiness CA-1 O=Equifax Secure Inc. # Subject: CN=Equifax Secure eBusiness CA-1 O=Equifax Secure Inc. # Label: "Equifax Secure eBusiness CA 1" # Serial: 4 # MD5 Fingerprint: 64:9c:ef:2e:44:fc:c6:8f:52:07:d0:51:73:8f:cb:3d # SHA1 Fingerprint: da:40:18:8b:91:89:a3:ed:ee:ae:da:97:fe:2f:9d:f5:b7:d1:8a:41 # SHA256 Fingerprint: cf:56:ff:46:a4:a1:86:10:9d:d9:65:84:b5:ee:b5:8a:51:0c:42:75:b0:e5:f9:4f:40:bb:ae:86:5e:19:f6:73 -----BEGIN CERTIFICATE----- MIICgjCCAeugAwIBAgIBBDANBgkqhkiG9w0BAQQFADBTMQswCQYDVQQGEwJVUzEc MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEmMCQGA1UEAxMdRXF1aWZheCBT ZWN1cmUgZUJ1c2luZXNzIENBLTEwHhcNOTkwNjIxMDQwMDAwWhcNMjAwNjIxMDQw MDAwWjBTMQswCQYDVQQGEwJVUzEcMBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5j LjEmMCQGA1UEAxMdRXF1aWZheCBTZWN1cmUgZUJ1c2luZXNzIENBLTEwgZ8wDQYJ KoZIhvcNAQEBBQADgY0AMIGJAoGBAM4vGbwXt3fek6lfWg0XTzQaDJj0ItlZ1MRo RvC0NcWFAyDGr0WlIVFFQesWWDYyb+JQYmT5/VGcqiTZ9J2DKocKIdMSODRsjQBu WqDZQu4aIZX5UkxVWsUPOE9G+m34LjXWHXzr4vCwdYDIqROsvojvOm6rXyo4YgKw Env+j6YDAgMBAAGjZjBkMBEGCWCGSAGG+EIBAQQEAwIABzAPBgNVHRMBAf8EBTAD AQH/MB8GA1UdIwQYMBaAFEp4MlIR21kWNl7fwRQ2QGpHfEyhMB0GA1UdDgQWBBRK eDJSEdtZFjZe38EUNkBqR3xMoTANBgkqhkiG9w0BAQQFAAOBgQB1W6ibAxHm6VZM zfmpTMANmvPMZWnmJXbMWbfWVMMdzZmsGd20hdXgPfxiIKeES1hl8eL5lSE/9dR+ WB5Hh1Q+WKG1tfgq73HnvMP2sUlG4tega+VWeponmHxGYhTnyfxuAxJ5gDgdSIKN /Bf+KpYrtWKmpj29f5JZzVoqgrI3eQ== -----END CERTIFICATE----- # Issuer: O=Equifax Secure OU=Equifax Secure eBusiness CA-2 # Subject: O=Equifax Secure OU=Equifax Secure eBusiness CA-2 # Label: "Equifax Secure eBusiness CA 2" # Serial: 930140085 # MD5 Fingerprint: aa:bf:bf:64:97:da:98:1d:6f:c6:08:3a:95:70:33:ca # SHA1 Fingerprint: 39:4f:f6:85:0b:06:be:52:e5:18:56:cc:10:e1:80:e8:82:b3:85:cc # SHA256 Fingerprint: 2f:27:4e:48:ab:a4:ac:7b:76:59:33:10:17:75:50:6d:c3:0e:e3:8e:f6:ac:d5:c0:49:32:cf:e0:41:23:42:20 -----BEGIN CERTIFICATE----- MIIDIDCCAomgAwIBAgIEN3DPtTANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV UzEXMBUGA1UEChMORXF1aWZheCBTZWN1cmUxJjAkBgNVBAsTHUVxdWlmYXggU2Vj dXJlIGVCdXNpbmVzcyBDQS0yMB4XDTk5MDYyMzEyMTQ0NVoXDTE5MDYyMzEyMTQ0 NVowTjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDkVxdWlmYXggU2VjdXJlMSYwJAYD VQQLEx1FcXVpZmF4IFNlY3VyZSBlQnVzaW5lc3MgQ0EtMjCBnzANBgkqhkiG9w0B AQEFAAOBjQAwgYkCgYEA5Dk5kx5SBhsoNviyoynF7Y6yEb3+6+e0dMKP/wXn2Z0G vxLIPw7y1tEkshHe0XMJitSxLJgJDR5QRrKDpkWNYmi7hRsgcDKqQM2mll/EcTc/ BPO3QSQ5BxoeLmFYoBIL5aXfxavqN3HMHMg3OrmXUqesxWoklE6ce8/AatbfIb0C AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEX MBUGA1UEChMORXF1aWZheCBTZWN1cmUxJjAkBgNVBAsTHUVxdWlmYXggU2VjdXJl IGVCdXNpbmVzcyBDQS0yMQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTkw NjIzMTIxNDQ1WjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUUJ4L6q9euSBIplBq y/3YIHqngnYwHQYDVR0OBBYEFFCeC+qvXrkgSKZQasv92CB6p4J2MAwGA1UdEwQF MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA A4GBAAyGgq3oThr1jokn4jVYPSm0B482UJW/bsGe68SQsoWou7dC4A8HOd/7npCy 0cE+U58DRLB+S/Rv5Hwf5+Kx5Lia78O9zt4LMjTZ3ijtM2vE1Nc9ElirfQkty3D1 E4qUoSek1nDFbZS1yX2doNLGCEnZZpum0/QL3MUmV+GRMOrN -----END CERTIFICATE----- # Issuer: CN=AddTrust Class 1 CA Root O=AddTrust AB OU=AddTrust TTP Network # Subject: CN=AddTrust Class 1 CA Root O=AddTrust AB OU=AddTrust TTP Network # Label: "AddTrust Low-Value Services Root" # Serial: 1 # MD5 Fingerprint: 1e:42:95:02:33:92:6b:b9:5f:c0:7f:da:d6:b2:4b:fc # SHA1 Fingerprint: cc:ab:0e:a0:4c:23:01:d6:69:7b:dd:37:9f:cd:12:eb:24:e3:94:9d # SHA256 Fingerprint: 8c:72:09:27:9a:c0:4e:27:5e:16:d0:7f:d3:b7:75:e8:01:54:b5:96:80:46:e3:1f:52:dd:25:76:63:24:e9:a7 -----BEGIN CERTIFICATE----- MIIEGDCCAwCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBlMQswCQYDVQQGEwJTRTEU MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwHhcNMDAwNTMw MTAzODMxWhcNMjAwNTMwMTAzODMxWjBlMQswCQYDVQQGEwJTRTEUMBIGA1UEChML QWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYD VQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUA A4IBDwAwggEKAoIBAQCWltQhSWDia+hBBwzexODcEyPNwTXH+9ZOEQpnXvUGW2ul CDtbKRY654eyNAbFvAWlA3yCyykQruGIgb3WntP+LVbBFc7jJp0VLhD7Bo8wBN6n tGO0/7Gcrjyvd7ZWxbWroulpOj0OM3kyP3CCkplhbY0wCI9xP6ZIVxn4JdxLZlyl dI+Yrsj5wAYi56xz36Uu+1LcsRVlIPo1Zmne3yzxbrww2ywkEtvrNTVokMsAsJch PXQhI2U0K7t4WaPW4XY5mqRJjox0r26kmqPZm9I4XJuiGMx1I4S+6+JNM3GOGvDC +Mcdoq0Dlyz4zyXG9rgkMbFjXZJ/Y/AlyVMuH79NAgMBAAGjgdIwgc8wHQYDVR0O BBYEFJWxtPCUtr3H2tERCSG+wa9J/RB7MAsGA1UdDwQEAwIBBjAPBgNVHRMBAf8E BTADAQH/MIGPBgNVHSMEgYcwgYSAFJWxtPCUtr3H2tERCSG+wa9J/RB7oWmkZzBl MQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFk ZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENB IFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBACxtZBsfzQ3duQH6lmM0MkhHma6X 7f1yFqZzR1r0693p9db7RcwpiURdv0Y5PejuvE1Uhh4dbOMXJ0PhiVYrqW9yTkkz 43J8KiOavD7/KCrto/8cI7pDVwlnTUtiBi34/2ydYB7YHEt9tTEv2dB8Xfjea4MY eDdXL+gzB2ffHsdrKpV2ro9Xo/D0UrSpUwjP4E/TelOL/bscVjby/rK25Xa71SJl pz/+0WatC7xrmYbvP33zGDLKe8bjq2RGlfgmadlVg3sslgf/WSxEo8bl6ancoWOA WiFeIc9TVPC6b4nbqKqVz4vjccweGyBECMB6tkD9xOQ14R0WHNC8K47Wcdk= -----END CERTIFICATE----- # Issuer: CN=AddTrust External CA Root O=AddTrust AB OU=AddTrust External TTP Network # Subject: CN=AddTrust External CA Root O=AddTrust AB OU=AddTrust External TTP Network # Label: "AddTrust External Root" # Serial: 1 # MD5 Fingerprint: 1d:35:54:04:85:78:b0:3f:42:42:4d:bf:20:73:0a:3f # SHA1 Fingerprint: 02:fa:f3:e2:91:43:54:68:60:78:57:69:4d:f5:e4:5b:68:85:18:68 # SHA256 Fingerprint: 68:7f:a4:51:38:22:78:ff:f0:c8:b1:1f:8d:43:d5:76:67:1c:6e:b2:bc:ea:b4:13:fb:83:d9:65:d0:6d:2f:f2 -----BEGIN CERTIFICATE----- MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290 MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9 uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0 WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0 Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5 6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ= -----END CERTIFICATE----- # Issuer: CN=AddTrust Public CA Root O=AddTrust AB OU=AddTrust TTP Network # Subject: CN=AddTrust Public CA Root O=AddTrust AB OU=AddTrust TTP Network # Label: "AddTrust Public Services Root" # Serial: 1 # MD5 Fingerprint: c1:62:3e:23:c5:82:73:9c:03:59:4b:2b:e9:77:49:7f # SHA1 Fingerprint: 2a:b6:28:48:5e:78:fb:f3:ad:9e:79:10:dd:6b:df:99:72:2c:96:e5 # SHA256 Fingerprint: 07:91:ca:07:49:b2:07:82:aa:d3:c7:d7:bd:0c:df:c9:48:58:35:84:3e:b2:d7:99:60:09:ce:43:ab:6c:69:27 -----BEGIN CERTIFICATE----- MIIEFTCCAv2gAwIBAgIBATANBgkqhkiG9w0BAQUFADBkMQswCQYDVQQGEwJTRTEU MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 b3JrMSAwHgYDVQQDExdBZGRUcnVzdCBQdWJsaWMgQ0EgUm9vdDAeFw0wMDA1MzAx MDQxNTBaFw0yMDA1MzAxMDQxNTBaMGQxCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtB ZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIDAeBgNV BAMTF0FkZFRydXN0IFB1YmxpYyBDQSBSb290MIIBIjANBgkqhkiG9w0BAQEFAAOC AQ8AMIIBCgKCAQEA6Rowj4OIFMEg2Dybjxt+A3S72mnTRqX4jsIMEZBRpS9mVEBV 6tsfSlbunyNu9DnLoblv8n75XYcmYZ4c+OLspoH4IcUkzBEMP9smcnrHAZcHF/nX GCwwfQ56HmIexkvA/X1id9NEHif2P0tEs7c42TkfYNVRknMDtABp4/MUTu7R3AnP dzRGULD4EfL+OHn3Bzn+UZKXC1sIXzSGAa2Il+tmzV7R/9x98oTaunet3IAIx6eH 1lWfl2royBFkuucZKT8Rs3iQhCBSWxHveNCD9tVIkNAwHM+A+WD+eeSI8t0A65RF 62WUaUC6wNW0uLp9BBGo6zEFlpROWCGOn9Bg/QIDAQABo4HRMIHOMB0GA1UdDgQW BBSBPjfYkrAfd59ctKtzquf2NGAv+jALBgNVHQ8EBAMCAQYwDwYDVR0TAQH/BAUw AwEB/zCBjgYDVR0jBIGGMIGDgBSBPjfYkrAfd59ctKtzquf2NGAv+qFopGYwZDEL MAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQLExRBZGRU cnVzdCBUVFAgTmV0d29yazEgMB4GA1UEAxMXQWRkVHJ1c3QgUHVibGljIENBIFJv b3SCAQEwDQYJKoZIhvcNAQEFBQADggEBAAP3FUr4JNojVhaTdt02KLmuG7jD8WS6 IBh4lSknVwW8fCr0uVFV2ocC3g8WFzH4qnkuCRO7r7IgGRLlk/lL+YPoRNWyQSW/ iHVv/xD8SlTQX/D67zZzfRs2RcYhbbQVuE7PnFylPVoAjgbjPGsye/Kf8Lb93/Ao GEjwxrzQvzSAlsJKsW2Ox5BF3i9nrEUEo3rcVZLJR2bYGozH7ZxOmuASu7VqTITh 4SINhwBk/ox9Yjllpu9CtoAlEmEBqCQTcAARJl/6NVDFSMwGR+gn2HCNX2TmoUQm XiLsks3/QppEIW1cxeMiHV9HEufOX1362KqxMy3ZdvJOOjMMK7MtkAY= -----END CERTIFICATE----- # Issuer: CN=AddTrust Qualified CA Root O=AddTrust AB OU=AddTrust TTP Network # Subject: CN=AddTrust Qualified CA Root O=AddTrust AB OU=AddTrust TTP Network # Label: "AddTrust Qualified Certificates Root" # Serial: 1 # MD5 Fingerprint: 27:ec:39:47:cd:da:5a:af:e2:9a:01:65:21:a9:4c:bb # SHA1 Fingerprint: 4d:23:78:ec:91:95:39:b5:00:7f:75:8f:03:3b:21:1e:c5:4d:8b:cf # SHA256 Fingerprint: 80:95:21:08:05:db:4b:bc:35:5e:44:28:d8:fd:6e:c2:cd:e3:ab:5f:b9:7a:99:42:98:8e:b8:f4:dc:d0:60:16 -----BEGIN CERTIFICATE----- MIIEHjCCAwagAwIBAgIBATANBgkqhkiG9w0BAQUFADBnMQswCQYDVQQGEwJTRTEU MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 b3JrMSMwIQYDVQQDExpBZGRUcnVzdCBRdWFsaWZpZWQgQ0EgUm9vdDAeFw0wMDA1 MzAxMDQ0NTBaFw0yMDA1MzAxMDQ0NTBaMGcxCzAJBgNVBAYTAlNFMRQwEgYDVQQK EwtBZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIzAh BgNVBAMTGkFkZFRydXN0IFF1YWxpZmllZCBDQSBSb290MIIBIjANBgkqhkiG9w0B AQEFAAOCAQ8AMIIBCgKCAQEA5B6a/twJWoekn0e+EV+vhDTbYjx5eLfpMLXsDBwq xBb/4Oxx64r1EW7tTw2R0hIYLUkVAcKkIhPHEWT/IhKauY5cLwjPcWqzZwFZ8V1G 87B4pfYOQnrjfxvM0PC3KP0q6p6zsLkEqv32x7SxuCqg+1jxGaBvcCV+PmlKfw8i 2O+tCBGaKZnhqkRFmhJePp1tUvznoD1oL/BLcHwTOK28FSXx1s6rosAx1i+f4P8U WfyEk9mHfExUE+uf0S0R+Bg6Ot4l2ffTQO2kBhLEO+GRwVY18BTcZTYJbqukB8c1 0cIDMzZbdSZtQvESa0NvS3GU+jQd7RNuyoB/mC9suWXY6QIDAQABo4HUMIHRMB0G A1UdDgQWBBQ5lYtii1zJ1IC6WA+XPxUIQ8yYpzALBgNVHQ8EBAMCAQYwDwYDVR0T AQH/BAUwAwEB/zCBkQYDVR0jBIGJMIGGgBQ5lYtii1zJ1IC6WA+XPxUIQ8yYp6Fr pGkwZzELMAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQL ExRBZGRUcnVzdCBUVFAgTmV0d29yazEjMCEGA1UEAxMaQWRkVHJ1c3QgUXVhbGlm aWVkIENBIFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBABmrder4i2VhlRO6aQTv hsoToMeqT2QbPxj2qC0sVY8FtzDqQmodwCVRLae/DLPt7wh/bDxGGuoYQ992zPlm hpwsaPXpF/gxsxjE1kh9I0xowX67ARRvxdlu3rsEQmr49lx95dr6h+sNNVJn0J6X dgWTP5XHAeZpVTh/EGGZyeNfpso+gmNIquIISD6q8rKFYqa0p9m9N5xotS1WfbC3 P6CxB9bpT9zeRXEwMn8bLgn5v1Kh7sKAPgZcLlVAwRv1cEWw3F369nJad9Jjzc9Y iQBCYz95OdBEsIJuQRno3eDBiFrRHnGTHyQwdOUeqN48Jzd/g66ed8/wMLH/S5no xqE= -----END CERTIFICATE----- # Issuer: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc. # Subject: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc. # Label: "Entrust Root Certification Authority" # Serial: 1164660820 # MD5 Fingerprint: d6:a5:c3:ed:5d:dd:3e:00:c1:3d:87:92:1f:1d:3f:e4 # SHA1 Fingerprint: b3:1e:b1:b7:40:e3:6c:84:02:da:dc:37:d4:4d:f5:d4:67:49:52:f9 # SHA256 Fingerprint: 73:c1:76:43:4f:1b:c6:d5:ad:f4:5b:0e:76:e7:27:28:7c:8d:e5:76:16:c1:e6:e6:14:1a:2b:2c:bc:7d:8e:4c -----BEGIN CERTIFICATE----- MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0 Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4 4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9 KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi 94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP 9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/ eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m 0vdXcDazv/wor3ElhVsT/h5/WrQ8 -----END CERTIFICATE----- # Issuer: CN=GeoTrust Global CA O=GeoTrust Inc. # Subject: CN=GeoTrust Global CA O=GeoTrust Inc. # Label: "GeoTrust Global CA" # Serial: 144470 # MD5 Fingerprint: f7:75:ab:29:fb:51:4e:b7:77:5e:ff:05:3c:99:8e:f5 # SHA1 Fingerprint: de:28:f4:a4:ff:e5:b9:2f:a3:c5:03:d1:a3:49:a7:f9:96:2a:82:12 # SHA256 Fingerprint: ff:85:6a:2d:25:1d:cd:88:d3:66:56:f4:50:12:67:98:cf:ab:aa:de:40:79:9c:72:2d:e4:d2:b5:db:36:a7:3a -----BEGIN CERTIFICATE----- MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9 9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU 1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+ bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV 5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw== -----END CERTIFICATE----- # Issuer: CN=GeoTrust Global CA 2 O=GeoTrust Inc. # Subject: CN=GeoTrust Global CA 2 O=GeoTrust Inc. # Label: "GeoTrust Global CA 2" # Serial: 1 # MD5 Fingerprint: 0e:40:a7:6c:de:03:5d:8f:d1:0f:e4:d1:8d:f9:6c:a9 # SHA1 Fingerprint: a9:e9:78:08:14:37:58:88:f2:05:19:b0:6d:2b:0d:2b:60:16:90:7d # SHA256 Fingerprint: ca:2d:82:a0:86:77:07:2f:8a:b6:76:4f:f0:35:67:6c:fe:3e:5e:32:5e:01:21:72:df:3f:92:09:6d:b7:9b:85 -----BEGIN CERTIFICATE----- MIIDZjCCAk6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJVUzEW MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3QgR2xvYmFs IENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMTkwMzA0MDUwMDAwWjBEMQswCQYDVQQG EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3Qg R2xvYmFsIENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDvPE1A PRDfO1MA4Wf+lGAVPoWI8YkNkMgoI5kF6CsgncbzYEbYwbLVjDHZ3CB5JIG/NTL8 Y2nbsSpr7iFY8gjpeMtvy/wWUsiRxP89c96xPqfCfWbB9X5SJBri1WeR0IIQ13hL TytCOb1kLUCgsBDTOEhGiKEMuzozKmKY+wCdE1l/bztyqu6mD4b5BWHqZ38MN5aL 5mkWRxHCJ1kDs6ZgwiFAVvqgx306E+PsV8ez1q6diYD3Aecs9pYrEw15LNnA5IZ7 S4wMcoKK+xfNAGw6EzywhIdLFnopsk/bHdQL82Y3vdj2V7teJHq4PIu5+pIaGoSe 2HSPqht/XvT+RSIhAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE FHE4NvICMVNHK266ZUapEBVYIAUJMB8GA1UdIwQYMBaAFHE4NvICMVNHK266ZUap EBVYIAUJMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQUFAAOCAQEAA/e1K6td EPx7srJerJsOflN4WT5CBP51o62sgU7XAotexC3IUnbHLB/8gTKY0UvGkpMzNTEv /NgdRN3ggX+d6YvhZJFiCzkIjKx0nVnZellSlxG5FntvRdOW2TF9AjYPnDtuzywN A0ZF66D0f0hExghAzN4bcLUprbqLOzRldRtxIR0sFAqwlpW41uryZfspuk/qkZN0 abby/+Ea0AzRdoXLiiW9l14sbxWZJue2Kf8i7MkCx1YAzUm5s2x7UwQa4qjJqhIF I8LO57sEAszAR6LkxCkvW0VXiVHuPOtSCP8HNR6fNWpHSlaY0VqFH4z1Ir+rzoPz 4iIprn2DQKi6bA== -----END CERTIFICATE----- # Issuer: CN=GeoTrust Universal CA O=GeoTrust Inc. # Subject: CN=GeoTrust Universal CA O=GeoTrust Inc. # Label: "GeoTrust Universal CA" # Serial: 1 # MD5 Fingerprint: 92:65:58:8b:a2:1a:31:72:73:68:5c:b4:a5:7a:07:48 # SHA1 Fingerprint: e6:21:f3:35:43:79:05:9a:4b:68:30:9d:8a:2f:74:22:15:87:ec:79 # SHA256 Fingerprint: a0:45:9b:9f:63:b2:25:59:f5:fa:5d:4c:6d:b3:f9:f7:2f:f1:93:42:03:35:78:f0:73:bf:1d:1b:46:cb:b9:12 -----BEGIN CERTIFICATE----- MIIFaDCCA1CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJVUzEW MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEeMBwGA1UEAxMVR2VvVHJ1c3QgVW5pdmVy c2FsIENBMB4XDTA0MDMwNDA1MDAwMFoXDTI5MDMwNDA1MDAwMFowRTELMAkGA1UE BhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xHjAcBgNVBAMTFUdlb1RydXN0 IFVuaXZlcnNhbCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKYV VaCjxuAfjJ0hUNfBvitbtaSeodlyWL0AG0y/YckUHUWCq8YdgNY96xCcOq9tJPi8 cQGeBvV8Xx7BDlXKg5pZMK4ZyzBIle0iN430SppyZj6tlcDgFgDgEB8rMQ7XlFTT QjOgNB0eRXbdT8oYN+yFFXoZCPzVx5zw8qkuEKmS5j1YPakWaDwvdSEYfyh3peFh F7em6fgemdtzbvQKoiFs7tqqhZJmr/Z6a4LauiIINQ/PQvE1+mrufislzDoR5G2v c7J2Ha3QsnhnGqQ5HFELZ1aD/ThdDc7d8Lsrlh/eezJS/R27tQahsiFepdaVaH/w mZ7cRQg+59IJDTWU3YBOU5fXtQlEIGQWFwMCTFMNaN7VqnJNk22CDtucvc+081xd VHppCZbW2xHBjXWotM85yM48vCR85mLK4b19p71XZQvk/iXttmkQ3CgaRr0BHdCX teGYO8A3ZNY9lO4L4fUorgtWv3GLIylBjobFS1J72HGrH4oVpjuDWtdYAVHGTEHZ f9hBZ3KiKN9gg6meyHv8U3NyWfWTehd2Ds735VzZC1U0oqpbtWpU5xPKV+yXbfRe Bi9Fi1jUIxaS5BZuKGNZMN9QAZxjiRqf2xeUgnA3wySemkfWWspOqGmJch+RbNt+ nhutxx9z3SxPGWX9f5NAEC7S8O08ni4oPmkmM8V7AgMBAAGjYzBhMA8GA1UdEwEB /wQFMAMBAf8wHQYDVR0OBBYEFNq7LqqwDLiIJlF0XG0D08DYj3rWMB8GA1UdIwQY MBaAFNq7LqqwDLiIJlF0XG0D08DYj3rWMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG 9w0BAQUFAAOCAgEAMXjmx7XfuJRAyXHEqDXsRh3ChfMoWIawC/yOsjmPRFWrZIRc aanQmjg8+uUfNeVE44B5lGiku8SfPeE0zTBGi1QrlaXv9z+ZhP015s8xxtxqv6fX IwjhmF7DWgh2qaavdy+3YL1ERmrvl/9zlcGO6JP7/TG37FcREUWbMPEaiDnBTzyn ANXH/KttgCJwpQzgXQQpAvvLoJHRfNbDflDVnVi+QTjruXU8FdmbyUqDWcDaU/0z uzYYm4UPFd3uLax2k7nZAY1IEKj79TiG8dsKxr2EoyNB3tZ3b4XUhRxQ4K5RirqN Pnbiucon8l+f725ZDQbYKxek0nxru18UGkiPGkzns0ccjkxFKyDuSN/n3QmOGKja QI2SJhFTYXNd673nxE0pN2HrrDktZy4W1vUAg4WhzH92xH3kt0tm7wNFYGm2DFKW koRepqO1pD4r2czYG0eq8kTaT/kD6PAUyz/zg97QwVTjt+gKN02LIFkDMBmhLMi9 ER/frslKxfMnZmaGrGiR/9nmUxwPi1xpZQomyB40w11Re9epnAahNt3ViZS82eQt DF4JbAiXfKM9fJP/P6EUp8+1Xevb2xzEdt+Iub1FBZUbrvxGakyvSOPOrg/Sfuvm bJxPgWp6ZKy7PtXny3YuxadIwVyQD8vIP/rmMuGNG2+k5o7Y+SlIis5z/iw= -----END CERTIFICATE----- # Issuer: CN=GeoTrust Universal CA 2 O=GeoTrust Inc. # Subject: CN=GeoTrust Universal CA 2 O=GeoTrust Inc. # Label: "GeoTrust Universal CA 2" # Serial: 1 # MD5 Fingerprint: 34:fc:b8:d0:36:db:9e:14:b3:c2:f2:db:8f:e4:94:c7 # SHA1 Fingerprint: 37:9a:19:7b:41:85:45:35:0c:a6:03:69:f3:3c:2e:af:47:4f:20:79 # SHA256 Fingerprint: a0:23:4f:3b:c8:52:7c:a5:62:8e:ec:81:ad:5d:69:89:5d:a5:68:0d:c9:1d:1c:b8:47:7f:33:f8:78:b9:5b:0b -----BEGIN CERTIFICATE----- MIIFbDCCA1SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBHMQswCQYDVQQGEwJVUzEW MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1c3QgVW5pdmVy c2FsIENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMjkwMzA0MDUwMDAwWjBHMQswCQYD VQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1 c3QgVW5pdmVyc2FsIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC AQCzVFLByT7y2dyxUxpZKeexw0Uo5dfR7cXFS6GqdHtXr0om/Nj1XqduGdt0DE81 WzILAePb63p3NeqqWuDW6KFXlPCQo3RWlEQwAx5cTiuFJnSCegx2oG9NzkEtoBUG FF+3Qs17j1hhNNwqCPkuwwGmIkQcTAeC5lvO0Ep8BNMZcyfwqph/Lq9O64ceJHdq XbboW0W63MOhBW9Wjo8QJqVJwy7XQYci4E+GymC16qFjwAGXEHm9ADwSbSsVsaxL se4YuU6W3Nx2/zu+z18DwPw76L5GG//aQMJS9/7jOvdqdzXQ2o3rXhhqMcceujwb KNZrVMaqW9eiLBsZzKIC9ptZvTdrhrVtgrrY6slWvKk2WP0+GfPtDCapkzj4T8Fd IgbQl+rhrcZV4IErKIM6+vR7IVEAvlI4zs1meaj0gVbi0IMJR1FbUGrP20gaXT73 y/Zl92zxlfgCOzJWgjl6W70viRu/obTo/3+NjN8D8WBOWBFM66M/ECuDmgFz2ZRt hAAnZqzwcEAJQpKtT5MNYQlRJNiS1QuUYbKHsu3/mjX/hVTK7URDrBs8FmtISgoc QIgfksILAAX/8sgCSqSqqcyZlpwvWOB94b67B9xfBHJcMTTD7F8t4D1kkCLm0ey4 Lt1ZrtmhN79UNdxzMk+MBB4zsslG8dhcyFVQyWi9qLo2CQIDAQABo2MwYTAPBgNV HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAfBgNV HSMEGDAWgBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAOBgNVHQ8BAf8EBAMCAYYwDQYJ KoZIhvcNAQEFBQADggIBAGbBxiPz2eAubl/oz66wsCVNK/g7WJtAJDday6sWSf+z dXkzoS9tcBc0kf5nfo/sm+VegqlVHy/c1FEHEv6sFj4sNcZj/NwQ6w2jqtB8zNHQ L1EuxBRa3ugZ4T7GzKQp5y6EqgYweHZUcyiYWTjgAA1i00J9IZ+uPTqM1fp3DRgr Fg5fNuH8KrUwJM/gYwx7WBr+mbpCErGR9Hxo4sjoryzqyX6uuyo9DRXcNJW2GHSo ag/HtPQTxORb7QrSpJdMKu0vbBKJPfEncKpqA1Ihn0CoZ1Dy81of398j9tx4TuaY T1U6U+Pv8vSfx3zYWK8pIpe44L2RLrB27FcRz+8pRPPphXpgY+RdM4kX2TGq2tbz GDVyz4crL2MjhF2EjD9XoIj8mZEoJmmZ1I+XRL6O1UixpCgp8RW04eWe3fiPpm8m 1wk8OhwRDqZsN/etRIcsKMfYdIKz0G9KV7s1KSegi+ghp4dkNl3M2Basx7InQJJV OCiNUW7dFGdTbHFcJoRNdVq2fmBWqU2t+5sel/MN2dKXVHfaPRK34B7vCAas+YWH 6aLcr34YEoP9VhdBLtUpgn2Z9DH2canPLAEnpQW5qrJITirvn5NSUZU8UnOOVkwX QMAJKOSLakhT2+zNVVXxxvjpoixMptEmX36vWkzaH6byHCx+rgIW0lbQL1dTR+iS -----END CERTIFICATE----- # Issuer: CN=America Online Root Certification Authority 1 O=America Online Inc. # Subject: CN=America Online Root Certification Authority 1 O=America Online Inc. # Label: "America Online Root Certification Authority 1" # Serial: 1 # MD5 Fingerprint: 14:f1:08:ad:9d:fa:64:e2:89:e7:1c:cf:a8:ad:7d:5e # SHA1 Fingerprint: 39:21:c1:15:c1:5d:0e:ca:5c:cb:5b:c4:f0:7d:21:d8:05:0b:56:6a # SHA256 Fingerprint: 77:40:73:12:c6:3a:15:3d:5b:c0:0b:4e:51:75:9c:df:da:c2:37:dc:2a:33:b6:79:46:e9:8e:9b:fa:68:0a:e3 -----BEGIN CERTIFICATE----- MIIDpDCCAoygAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEc MBoGA1UEChMTQW1lcmljYSBPbmxpbmUgSW5jLjE2MDQGA1UEAxMtQW1lcmljYSBP bmxpbmUgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAxMB4XDTAyMDUyODA2 MDAwMFoXDTM3MTExOTIwNDMwMFowYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0Ft ZXJpY2EgT25saW5lIEluYy4xNjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3Qg Q2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP ADCCAQoCggEBAKgv6KRpBgNHw+kqmP8ZonCaxlCyfqXfaE0bfA+2l2h9LaaLl+lk hsmj76CGv2BlnEtUiMJIxUo5vxTjWVXlGbR0yLQFOVwWpeKVBeASrlmLojNoWBym 1BW32J/X3HGrfpq/m44zDyL9Hy7nBzbvYjnF3cu6JRQj3gzGPTzOggjmZj7aUTsW OqMFf6Dch9Wc/HKpoH145LcxVR5lu9RhsCFg7RAycsWSJR74kEoYeEfffjA3PlAb 2xzTa5qGUwew76wGePiEmf4hjUyAtgyC9mZweRrTT6PP8c9GsEsPPt2IYriMqQko O3rHl+Ee5fSfwMCuJKDIodkP1nsmgmkyPacCAwEAAaNjMGEwDwYDVR0TAQH/BAUw AwEB/zAdBgNVHQ4EFgQUAK3Zo/Z59m50qX8zPYEX10zPM94wHwYDVR0jBBgwFoAU AK3Zo/Z59m50qX8zPYEX10zPM94wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB BQUAA4IBAQB8itEfGDeC4Liwo+1WlchiYZwFos3CYiZhzRAW18y0ZTTQEYqtqKkF Zu90821fnZmv9ov761KyBZiibyrFVL0lvV+uyIbqRizBs73B6UlwGBaXCBOMIOAb LjpHyx7kADCVW/RFo8AasAFOq73AI25jP4BKxQft3OJvx8Fi8eNy1gTIdGcL+oir oQHIb/AUr9KZzVGTfu0uOMe9zkZQPXLjeSWdm4grECDdpbgyn43gKd8hdIaC2y+C MMbHNYaz+ZZfRtsMRf3zUMNvxsNIrUam4SdHCh0Om7bCd39j8uB9Gr784N/Xx6ds sPmuujz9dLQR6FgNgLzTqIA6me11zEZ7 -----END CERTIFICATE----- # Issuer: CN=America Online Root Certification Authority 2 O=America Online Inc. # Subject: CN=America Online Root Certification Authority 2 O=America Online Inc. # Label: "America Online Root Certification Authority 2" # Serial: 1 # MD5 Fingerprint: d6:ed:3c:ca:e2:66:0f:af:10:43:0d:77:9b:04:09:bf # SHA1 Fingerprint: 85:b5:ff:67:9b:0c:79:96:1f:c8:6e:44:22:00:46:13:db:17:92:84 # SHA256 Fingerprint: 7d:3b:46:5a:60:14:e5:26:c0:af:fc:ee:21:27:d2:31:17:27:ad:81:1c:26:84:2d:00:6a:f3:73:06:cc:80:bd -----BEGIN CERTIFICATE----- MIIFpDCCA4ygAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEc MBoGA1UEChMTQW1lcmljYSBPbmxpbmUgSW5jLjE2MDQGA1UEAxMtQW1lcmljYSBP bmxpbmUgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAyMB4XDTAyMDUyODA2 MDAwMFoXDTM3MDkyOTE0MDgwMFowYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0Ft ZXJpY2EgT25saW5lIEluYy4xNjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3Qg Q2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIP ADCCAgoCggIBAMxBRR3pPU0Q9oyxQcngXssNt79Hc9PwVU3dxgz6sWYFas14tNwC 206B89enfHG8dWOgXeMHDEjsJcQDIPT/DjsS/5uN4cbVG7RtIuOx238hZK+GvFci KtZHgVdEglZTvYYUAQv8f3SkWq7xuhG1m1hagLQ3eAkzfDJHA1zEpYNI9FdWboE2 JxhP7JsowtS013wMPgwr38oE18aO6lhOqKSlGBxsRZijQdEt0sdtjRnxrXm3gT+9 BoInLRBYBbV4Bbkv2wxrkJB+FFk4u5QkE+XRnRTf04JNRvCAOVIyD+OEsnpD8l7e Xz8d3eOyG6ChKiMDbi4BFYdcpnV1x5dhvt6G3NRI270qv0pV2uh9UPu0gBe4lL8B PeraunzgWGcXuVjgiIZGZ2ydEEdYMtA1fHkqkKJaEBEjNa0vzORKW6fIJ/KD3l67 Xnfn6KVuY8INXWHQjNJsWiEOyiijzirplcdIz5ZvHZIlyMbGwcEMBawmxNJ10uEq Z8A9W6Wa6897GqidFEXlD6CaZd4vKL3Ob5Rmg0gp2OpljK+T2WSfVVcmv2/LNzGZ o2C7HK2JNDJiuEMhBnIMoVxtRsX6Kc8w3onccVvdtjc+31D1uAclJuW8tf48ArO3 +L5DwYcRlJ4jbBeKuIonDFRH8KmzwICMoCfrHRnjB453cMor9H124HhnAgMBAAGj YzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFE1FwWg4u3OpaaEg5+31IqEj FNeeMB8GA1UdIwQYMBaAFE1FwWg4u3OpaaEg5+31IqEjFNeeMA4GA1UdDwEB/wQE AwIBhjANBgkqhkiG9w0BAQUFAAOCAgEAZ2sGuV9FOypLM7PmG2tZTiLMubekJcmn xPBUlgtk87FYT15R/LKXeydlwuXK5w0MJXti4/qftIe3RUavg6WXSIylvfEWK5t2 LHo1YGwRgJfMqZJS5ivmae2p+DYtLHe/YUjRYwu5W1LtGLBDQiKmsXeu3mnFzccc obGlHBD7GL4acN3Bkku+KVqdPzW+5X1R+FXgJXUjhx5c3LqdsKyzadsXg8n33gy8 CNyRnqjQ1xU3c6U1uPx+xURABsPr+CKAXEfOAuMRn0T//ZoyzH1kUQ7rVyZ2OuMe IjzCpjbdGe+n/BLzJsBZMYVMnNjP36TMzCmT/5RtdlwTCJfy7aULTd3oyWgOZtMA DjMSW7yV5TKQqLPGbIOtd+6Lfn6xqavT4fG2wLHqiMDn05DpKJKUe2h7lyoKZy2F AjgQ5ANh1NolNscIWC2hp1GvMApJ9aZphwctREZ2jirlmjvXGKL8nDgQzMY70rUX Om/9riW99XJZZLF0KjhfGEzfz3EEWjbUvy+ZnOjZurGV5gJLIaFb1cFPj65pbVPb AZO1XB4Y3WRayhgoPmMEEf0cjQAPuDffZ4qdZqkCapH/E8ovXYO8h5Ns3CRRFgQl Zvqz2cK6Kb6aSDiCmfS/O0oxGfm/jiEzFMpPVF/7zvuPcX/9XhmgD0uRuMRUvAaw RY8mkaKO/qk= -----END CERTIFICATE----- # Issuer: CN=AAA Certificate Services O=Comodo CA Limited # Subject: CN=AAA Certificate Services O=Comodo CA Limited # Label: "Comodo AAA Services root" # Serial: 1 # MD5 Fingerprint: 49:79:04:b0:eb:87:19:ac:47:b0:bc:11:51:9b:74:d0 # SHA1 Fingerprint: d1:eb:23:a4:6d:17:d6:8f:d9:25:64:c2:f1:f1:60:17:64:d8:e3:49 # SHA256 Fingerprint: d7:a7:a0:fb:5d:7e:27:31:d7:71:e9:48:4e:bc:de:f7:1d:5f:0c:3e:0a:29:48:78:2b:c8:3e:e0:ea:69:9e:f4 -----BEGIN CERTIFICATE----- MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe 3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4 YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2 G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3 smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg== -----END CERTIFICATE----- # Issuer: CN=Secure Certificate Services O=Comodo CA Limited # Subject: CN=Secure Certificate Services O=Comodo CA Limited # Label: "Comodo Secure Services root" # Serial: 1 # MD5 Fingerprint: d3:d9:bd:ae:9f:ac:67:24:b3:c8:1b:52:e1:b9:a9:bd # SHA1 Fingerprint: 4a:65:d5:f4:1d:ef:39:b8:b8:90:4a:4a:d3:64:81:33:cf:c7:a1:d1 # SHA256 Fingerprint: bd:81:ce:3b:4f:65:91:d1:1a:67:b5:fc:7a:47:fd:ef:25:52:1b:f9:aa:4e:18:b9:e3:df:2e:34:a7:80:3b:e8 -----BEGIN CERTIFICATE----- MIIEPzCCAyegAwIBAgIBATANBgkqhkiG9w0BAQUFADB+MQswCQYDVQQGEwJHQjEb MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEkMCIGA1UEAwwbU2VjdXJlIENlcnRp ZmljYXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVow fjELMAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G A1UEBwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxJDAiBgNV BAMMG1NlY3VyZSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEB BQADggEPADCCAQoCggEBAMBxM4KK0HDrc4eCQNUd5MvJDkKQ+d40uaG6EfQlhfPM cm3ye5drswfxdySRXyWP9nQ95IDC+DwN879A6vfIUtFyb+/Iq0G4bi4XKpVpDM3S HpR7LZQdqnXXs5jLrLxkU0C8j6ysNstcrbvd4JQX7NFc0L/vpZXJkMWwrPsbQ996 CF23uPJAGysnnlDOXmWCiIxe004MeuoIkbY2qitC++rCoznl2yY4rYsK7hljxxwk 3wN42ubqwUcaCwtGCd0C/N7Lh1/XMGNooa7cMqG6vv5Eq2i2pRcV/b3Vp6ea5EQz 6YiO/O1R65NxTq0B50SOqy3LqP4BSUjwwN3HaNiS/j0CAwEAAaOBxzCBxDAdBgNV HQ4EFgQUPNiTiMLAggnMAZkGkyDpnnAJY08wDgYDVR0PAQH/BAQDAgEGMA8GA1Ud EwEB/wQFMAMBAf8wgYEGA1UdHwR6MHgwO6A5oDeGNWh0dHA6Ly9jcmwuY29tb2Rv Y2EuY29tL1NlY3VyZUNlcnRpZmljYXRlU2VydmljZXMuY3JsMDmgN6A1hjNodHRw Oi8vY3JsLmNvbW9kby5uZXQvU2VjdXJlQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmww DQYJKoZIhvcNAQEFBQADggEBAIcBbSMdflsXfcFhMs+P5/OKlFlm4J4oqF7Tt/Q0 5qo5spcWxYJvMqTpjOev/e/C6LlLqqP05tqNZSH7uoDrJiiFGv45jN5bBAS0VPmj Z55B+glSzAVIqMk/IQQezkhr/IXownuvf7fM+F86/TXGDe+X3EyrEeFryzHRbPtI gKvcnDe4IRRLDXE97IMzbtFuMhbsmMcWi1mmNKsFVy2T96oTy9IT4rcuO81rUBcJ aD61JlfutuC23bkpgHl9j6PwpCikFcSF9CfUa7/lXORlAnZUtOM3ZiTTGWHIUhDl izeauan5Hb/qmZJhlv8BzaFfDbxxvA6sCx1HRR3B7Hzs/Sk= -----END CERTIFICATE----- # Issuer: CN=Trusted Certificate Services O=Comodo CA Limited # Subject: CN=Trusted Certificate Services O=Comodo CA Limited # Label: "Comodo Trusted Services root" # Serial: 1 # MD5 Fingerprint: 91:1b:3f:6e:cd:9e:ab:ee:07:fe:1f:71:d2:b3:61:27 # SHA1 Fingerprint: e1:9f:e3:0e:8b:84:60:9e:80:9b:17:0d:72:a8:c5:ba:6e:14:09:bd # SHA256 Fingerprint: 3f:06:e5:56:81:d4:96:f5:be:16:9e:b5:38:9f:9f:2b:8f:f6:1e:17:08:df:68:81:72:48:49:cd:5d:27:cb:69 -----BEGIN CERTIFICATE----- MIIEQzCCAyugAwIBAgIBATANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJHQjEb MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDElMCMGA1UEAwwcVHJ1c3RlZCBDZXJ0 aWZpY2F0ZSBTZXJ2aWNlczAeFw0wNDAxMDEwMDAwMDBaFw0yODEyMzEyMzU5NTla MH8xCzAJBgNVBAYTAkdCMRswGQYDVQQIDBJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAO BgNVBAcMB1NhbGZvcmQxGjAYBgNVBAoMEUNvbW9kbyBDQSBMaW1pdGVkMSUwIwYD VQQDDBxUcnVzdGVkIENlcnRpZmljYXRlIFNlcnZpY2VzMIIBIjANBgkqhkiG9w0B AQEFAAOCAQ8AMIIBCgKCAQEA33FvNlhTWvI2VFeAxHQIIO0Yfyod5jWaHiWsnOWW fnJSoBVC21ndZHoa0Lh73TkVvFVIxO06AOoxEbrycXQaZ7jPM8yoMa+j49d/vzMt TGo87IvDktJTdyR0nAducPy9C1t2ul/y/9c3S0pgePfw+spwtOpZqqPOSC+pw7IL fhdyFgymBwwbOM/JYrc/oJOlh0Hyt3BAd9i+FHzjqMB6juljatEPmsbS9Is6FARW 1O24zG71++IsWL1/T2sr92AkWCTOJu80kTrV44HQsvAEAtdbtz6SrGsSivnkBbA7 kUlcsutT6vifR4buv5XAwAaf0lteERv0xwQ1KdJVXOTt6wIDAQABo4HJMIHGMB0G A1UdDgQWBBTFe1i97doladL3WRaoszLAeydb9DAOBgNVHQ8BAf8EBAMCAQYwDwYD VR0TAQH/BAUwAwEB/zCBgwYDVR0fBHwwejA8oDqgOIY2aHR0cDovL2NybC5jb21v ZG9jYS5jb20vVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMuY3JsMDqgOKA2hjRo dHRwOi8vY3JsLmNvbW9kby5uZXQvVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMu Y3JsMA0GCSqGSIb3DQEBBQUAA4IBAQDIk4E7ibSvuIQSTI3S8NtwuleGFTQQuS9/ HrCoiWChisJ3DFBKmwCL2Iv0QeLQg4pKHBQGsKNoBXAxMKdTmw7pSqBYaWcOrp32 pSxBvzwGa+RZzG0Q8ZZvH9/0BAKkn0U+yNj6NkZEUD+Cl5EfKNsYEYwq5GWDVxIS jBc/lDb+XbDABHcTuPQV1T84zJQ6VdCsmPW6AF/ghhmBeC8owH7TzEIK9a5QoNE+ xqFx7D+gIIxmOom0jtTYsU0lR+4viMi14QVFwL4Ucd56/Y57fU0IlqUSc/Atyjcn dBInTMu2l+nZrghtWjlA3QVHdWpaIbOjGM9O9y5Xt5hwXsjEeLBi -----END CERTIFICATE----- # Issuer: CN=UTN - DATACorp SGC O=The USERTRUST Network OU=http://www.usertrust.com # Subject: CN=UTN - DATACorp SGC O=The USERTRUST Network OU=http://www.usertrust.com # Label: "UTN DATACorp SGC Root CA" # Serial: 91374294542884689855167577680241077609 # MD5 Fingerprint: b3:a5:3e:77:21:6d:ac:4a:c0:c9:fb:d5:41:3d:ca:06 # SHA1 Fingerprint: 58:11:9f:0e:12:82:87:ea:50:fd:d9:87:45:6f:4f:78:dc:fa:d6:d4 # SHA256 Fingerprint: 85:fb:2f:91:dd:12:27:5a:01:45:b6:36:53:4f:84:02:4a:d6:8b:69:b8:ee:88:68:4f:f7:11:37:58:05:b3:48 -----BEGIN CERTIFICATE----- MIIEXjCCA0agAwIBAgIQRL4Mi1AAIbQR0ypoBqmtaTANBgkqhkiG9w0BAQUFADCB kzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xGzAZBgNVBAMTElVUTiAtIERBVEFDb3Jw IFNHQzAeFw05OTA2MjQxODU3MjFaFw0xOTA2MjQxOTA2MzBaMIGTMQswCQYDVQQG EwJVUzELMAkGA1UECBMCVVQxFzAVBgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYD VQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cu dXNlcnRydXN0LmNvbTEbMBkGA1UEAxMSVVROIC0gREFUQUNvcnAgU0dDMIIBIjAN BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3+5YEKIrblXEjr8uRgnn4AgPLit6 E5Qbvfa2gI5lBZMAHryv4g+OGQ0SR+ysraP6LnD43m77VkIVni5c7yPeIbkFdicZ D0/Ww5y0vpQZY/KmEQrrU0icvvIpOxboGqBMpsn0GFlowHDyUwDAXlCCpVZvNvlK 4ESGoE1O1kduSUrLZ9emxAW5jh70/P/N5zbgnAVssjMiFdC04MwXwLLA9P4yPykq lXvY8qdOD1R8oQ2AswkDwf9c3V6aPryuvEeKaq5xyh+xKrhfQgUL7EYw0XILyulW bfXv33i+Ybqypa4ETLyorGkVl73v67SMvzX41MPRKA5cOp9wGDMgd8SirwIDAQAB o4GrMIGoMAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRT MtGzz3/64PGgXYVOktKeRR20TzA9BgNVHR8ENjA0MDKgMKAuhixodHRwOi8vY3Js LnVzZXJ0cnVzdC5jb20vVVROLURBVEFDb3JwU0dDLmNybDAqBgNVHSUEIzAhBggr BgEFBQcDAQYKKwYBBAGCNwoDAwYJYIZIAYb4QgQBMA0GCSqGSIb3DQEBBQUAA4IB AQAnNZcAiosovcYzMB4p/OL31ZjUQLtgyr+rFywJNn9Q+kHcrpY6CiM+iVnJowft Gzet/Hy+UUla3joKVAgWRcKZsYfNjGjgaQPpxE6YsjuMFrMOoAyYUJuTqXAJyCyj j98C5OBxOvG0I3KgqgHf35g+FFCgMSa9KOlaMCZ1+XtgHI3zzVAmbQQnmt/VDUVH KWss5nbZqSl9Mt3JNjy9rjXxEZ4du5A/EkdOjtd+D2JzHVImOBwYSf0wdJrE5SIv 2MCN7ZF6TACPcn9d2t0bi0Vr591pl6jFVkwPDPafepE39peC4N1xaf92P2BNPM/3 mfnGV/TJVTl4uix5yaaIK/QI -----END CERTIFICATE----- # Issuer: CN=UTN-USERFirst-Hardware O=The USERTRUST Network OU=http://www.usertrust.com # Subject: CN=UTN-USERFirst-Hardware O=The USERTRUST Network OU=http://www.usertrust.com # Label: "UTN USERFirst Hardware Root CA" # Serial: 91374294542884704022267039221184531197 # MD5 Fingerprint: 4c:56:41:e5:0d:bb:2b:e8:ca:a3:ed:18:08:ad:43:39 # SHA1 Fingerprint: 04:83:ed:33:99:ac:36:08:05:87:22:ed:bc:5e:46:00:e3:be:f9:d7 # SHA256 Fingerprint: 6e:a5:47:41:d0:04:66:7e:ed:1b:48:16:63:4a:a3:a7:9e:6e:4b:96:95:0f:82:79:da:fc:8d:9b:d8:81:21:37 -----BEGIN CERTIFICATE----- MIIEdDCCA1ygAwIBAgIQRL4Mi1AAJLQR0zYq/mUK/TANBgkqhkiG9w0BAQUFADCB lzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3Qt SGFyZHdhcmUwHhcNOTkwNzA5MTgxMDQyWhcNMTkwNzA5MTgxOTIyWjCBlzELMAkG A1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0eTEe MBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8v d3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3QtSGFyZHdh cmUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCx98M4P7Sof885glFn 0G2f0v9Y8+efK+wNiVSZuTiZFvfgIXlIwrthdBKWHTxqctU8EGc6Oe0rE81m65UJ M6Rsl7HoxuzBdXmcRl6Nq9Bq/bkqVRcQVLMZ8Jr28bFdtqdt++BxF2uiiPsA3/4a MXcMmgF6sTLjKwEHOG7DpV4jvEWbe1DByTCP2+UretNb+zNAHqDVmBe8i4fDidNd oI6yqqr2jmmIBsX6iSHzCJ1pLgkzmykNRg+MzEk0sGlRvfkGzWitZky8PqxhvQqI DsjfPe58BEydCl5rkdbux+0ojatNh4lz0G6k0B4WixThdkQDf2Os5M1JnMWS9Ksy oUhbAgMBAAGjgbkwgbYwCwYDVR0PBAQDAgHGMA8GA1UdEwEB/wQFMAMBAf8wHQYD VR0OBBYEFKFyXyYbKJhDlV0HN9WFlp1L0sNFMEQGA1UdHwQ9MDswOaA3oDWGM2h0 dHA6Ly9jcmwudXNlcnRydXN0LmNvbS9VVE4tVVNFUkZpcnN0LUhhcmR3YXJlLmNy bDAxBgNVHSUEKjAoBggrBgEFBQcDAQYIKwYBBQUHAwUGCCsGAQUFBwMGBggrBgEF BQcDBzANBgkqhkiG9w0BAQUFAAOCAQEARxkP3nTGmZev/K0oXnWO6y1n7k57K9cM //bey1WiCuFMVGWTYGufEpytXoMs61quwOQt9ABjHbjAbPLPSbtNk28Gpgoiskli CE7/yMgUsogWXecB5BKV5UU0s4tpvc+0hY91UZ59Ojg6FEgSxvunOxqNDYJAB+gE CJChicsZUN/KHAG8HQQZexB2lzvukJDKxA4fFm517zP4029bHpbj4HR3dHuKom4t 3XbWOTCC8KucUvIqx69JXn7HaOWCgchqJ/kniCrVWFCVH/A7HFe7fRQ5YiuayZSS KqMiDP+JJn1fIytH1xUdqWqeUQ0qUZ6B+dQ7XnASfxAynB67nfhmqA== -----END CERTIFICATE----- # Issuer: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com # Subject: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com # Label: "XRamp Global CA Root" # Serial: 107108908803651509692980124233745014957 # MD5 Fingerprint: a1:0b:44:b3:ca:10:d8:00:6e:9d:0f:d8:0f:92:0a:d1 # SHA1 Fingerprint: b8:01:86:d1:eb:9c:86:a5:41:04:cf:30:54:f3:4c:52:b7:e5:58:c6 # SHA256 Fingerprint: ce:cd:dc:90:50:99:d8:da:df:c5:b1:d2:09:b7:37:cb:e2:c1:8c:fb:2c:10:c0:ff:0b:cf:0d:32:86:fc:1a:a2 -----BEGIN CERTIFICATE----- MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3 dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6 38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4 qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0 eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ O+7ETPTsJ3xCwnR8gooJybQDJbw= -----END CERTIFICATE----- # Issuer: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority # Subject: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority # Label: "Go Daddy Class 2 CA" # Serial: 0 # MD5 Fingerprint: 91:de:06:25:ab:da:fd:32:17:0c:bb:25:17:2a:84:67 # SHA1 Fingerprint: 27:96:ba:e6:3f:18:01:e2:77:26:1b:a0:d7:77:70:02:8f:20:ee:e4 # SHA256 Fingerprint: c3:84:6b:f2:4b:9e:93:ca:64:27:4c:0e:c6:7c:1e:cc:5e:02:4f:fc:ac:d2:d7:40:19:35:0e:81:fe:54:6a:e4 -----BEGIN CERTIFICATE----- MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3 MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+ YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h /t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5 IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf ReYNnyicsbkqWletNw+vHX/bvZ8= -----END CERTIFICATE----- # Issuer: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority # Subject: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority # Label: "Starfield Class 2 CA" # Serial: 0 # MD5 Fingerprint: 32:4a:4b:bb:c8:63:69:9b:be:74:9a:c6:dd:1d:46:24 # SHA1 Fingerprint: ad:7e:1c:28:b0:64:ef:8f:60:03:40:20:14:c3:d0:e3:37:0e:b5:8a # SHA256 Fingerprint: 14:65:fa:20:53:97:b8:76:fa:a6:f0:a9:95:8e:55:90:e4:0f:cc:7f:aa:4f:b7:c2:c8:67:75:21:fb:5f:b6:58 -----BEGIN CERTIFICATE----- MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3 DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf 8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN +lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0 X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA 1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0 YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3 L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q= -----END CERTIFICATE----- # Issuer: CN=StartCom Certification Authority O=StartCom Ltd. OU=Secure Digital Certificate Signing # Subject: CN=StartCom Certification Authority O=StartCom Ltd. OU=Secure Digital Certificate Signing # Label: "StartCom Certification Authority" # Serial: 1 # MD5 Fingerprint: 22:4d:8f:8a:fc:f7:35:c2:bb:57:34:90:7b:8b:22:16 # SHA1 Fingerprint: 3e:2b:f7:f2:03:1b:96:f3:8c:e6:c4:d8:a8:5d:3e:2d:58:47:6a:0f # SHA256 Fingerprint: c7:66:a9:be:f2:d4:07:1c:86:3a:31:aa:49:20:e8:13:b2:d1:98:60:8c:b7:b7:cf:e2:11:43:b8:36:df:09:ea -----BEGIN CERTIFICATE----- MIIHyTCCBbGgAwIBAgIBATANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJJTDEW MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM2WhcNMzYwOTE3MTk0NjM2WjB9 MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w +2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B 26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID AQABo4ICUjCCAk4wDAYDVR0TBAUwAwEB/zALBgNVHQ8EBAMCAa4wHQYDVR0OBBYE FE4L7xqkQFulF2mHMMo0aEPQQa7yMGQGA1UdHwRdMFswLKAqoCiGJmh0dHA6Ly9j ZXJ0LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMCugKaAnhiVodHRwOi8vY3Js LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMIIBXQYDVR0gBIIBVDCCAVAwggFM BgsrBgEEAYG1NwEBATCCATswLwYIKwYBBQUHAgEWI2h0dHA6Ly9jZXJ0LnN0YXJ0 Y29tLm9yZy9wb2xpY3kucGRmMDUGCCsGAQUFBwIBFilodHRwOi8vY2VydC5zdGFy dGNvbS5vcmcvaW50ZXJtZWRpYXRlLnBkZjCB0AYIKwYBBQUHAgIwgcMwJxYgU3Rh cnQgQ29tbWVyY2lhbCAoU3RhcnRDb20pIEx0ZC4wAwIBARqBl0xpbWl0ZWQgTGlh YmlsaXR5LCByZWFkIHRoZSBzZWN0aW9uICpMZWdhbCBMaW1pdGF0aW9ucyogb2Yg dGhlIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFBvbGljeSBhdmFp bGFibGUgYXQgaHR0cDovL2NlcnQuc3RhcnRjb20ub3JnL3BvbGljeS5wZGYwEQYJ YIZIAYb4QgEBBAQDAgAHMDgGCWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNT TCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTANBgkqhkiG9w0BAQUFAAOCAgEAFmyZ 9GYMNPXQhV59CuzaEE44HF7fpiUFS5Eyweg78T3dRAlbB0mKKctmArexmvclmAk8 jhvh3TaHK0u7aNM5Zj2gJsfyOZEdUauCe37Vzlrk4gNXcGmXCPleWKYK34wGmkUW FjgKXlf2Ysd6AgXmvB618p70qSmD+LIU424oh0TDkBreOKk8rENNZEXO3SipXPJz ewT4F+irsfMuXGRuczE6Eri8sxHkfY+BUZo7jYn0TZNmezwD7dOaHZrzZVD1oNB1 ny+v8OqCQ5j4aZyJecRDjkZy42Q2Eq/3JR44iZB3fsNrarnDy0RLrHiQi+fHLB5L EUTINFInzQpdn4XBidUaePKVEFMy3YCEZnXZtWgo+2EuvoSoOMCZEoalHmdkrQYu L6lwhceWD3yJZfWOQ1QOq92lgDmUYMA0yZZwLKMS9R9Ie70cfmu3nZD0Ijuu+Pwq yvqCUqDvr0tVk+vBtfAii6w0TiYiBKGHLHVKt+V9E9e4DGTANtLJL4YSjCMJwRuC O3NJo2pXh5Tl1njFmUNj403gdy3hZZlyaQQaRwnmDwFWJPsfvw55qVguucQJAX6V um0ABj6y6koQOdjQK/W/7HW/lwLFCRsI3FU34oH7N4RDYiDK51ZLZer+bMEkkySh NOsF/5oirpt9P/FlUQqmMGqz9IgcgA38corog14= -----END CERTIFICATE----- # Issuer: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com # Subject: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com # Label: "DigiCert Assured ID Root CA" # Serial: 17154717934120587862167794914071425081 # MD5 Fingerprint: 87:ce:0b:7b:2a:0e:49:00:e1:58:71:9b:37:a8:93:72 # SHA1 Fingerprint: 05:63:b8:63:0d:62:d7:5a:bb:c8:ab:1e:4b:df:b5:a8:99:b2:4d:43 # SHA256 Fingerprint: 3e:90:99:b5:01:5e:8f:48:6c:00:bc:ea:9d:11:1e:e7:21:fa:ba:35:5a:89:bc:f1:df:69:56:1e:3d:c6:32:5c -----BEGIN CERTIFICATE----- MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+ wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4 VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/ AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe +o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g== -----END CERTIFICATE----- # Issuer: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com # Subject: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com # Label: "DigiCert Global Root CA" # Serial: 10944719598952040374951832963794454346 # MD5 Fingerprint: 79:e4:a9:84:0d:7d:3a:96:d7:c0:4f:e2:43:4c:89:2e # SHA1 Fingerprint: a8:98:5d:3a:65:e5:e5:c4:b2:d7:d6:6d:40:c6:dd:2f:b1:9c:54:36 # SHA256 Fingerprint: 43:48:a0:e9:44:4c:78:cb:26:5e:05:8d:5e:89:44:b4:d8:4f:96:62:bd:26:db:25:7f:89:34:a4:43:c7:01:61 -----BEGIN CERTIFICATE----- MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG 9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97 nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt 43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4 gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg 06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4= -----END CERTIFICATE----- # Issuer: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com # Subject: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com # Label: "DigiCert High Assurance EV Root CA" # Serial: 3553400076410547919724730734378100087 # MD5 Fingerprint: d4:74:de:57:5c:39:b2:d3:9c:85:83:c5:c0:65:49:8a # SHA1 Fingerprint: 5f:b7:ee:06:33:e2:59:db:ad:0c:4c:9a:e6:d3:8f:1a:61:c7:dc:25 # SHA256 Fingerprint: 74:31:e5:f4:c3:c1:ce:46:90:77:4f:0b:61:e0:54:40:88:3b:a9:a0:1e:d0:0b:a6:ab:d7:80:6e:d3:b1:18:cf -----BEGIN CERTIFICATE----- MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3 LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm +9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3 hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2 Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep +OkuE6N36B9K -----END CERTIFICATE----- # Issuer: CN=GeoTrust Primary Certification Authority O=GeoTrust Inc. # Subject: CN=GeoTrust Primary Certification Authority O=GeoTrust Inc. # Label: "GeoTrust Primary Certification Authority" # Serial: 32798226551256963324313806436981982369 # MD5 Fingerprint: 02:26:c3:01:5e:08:30:37:43:a9:d0:7d:cf:37:e6:bf # SHA1 Fingerprint: 32:3c:11:8e:1b:f7:b8:b6:52:54:e2:e2:10:0d:d6:02:90:37:f0:96 # SHA256 Fingerprint: 37:d5:10:06:c5:12:ea:ab:62:64:21:f1:ec:8c:92:01:3f:c5:f8:2a:e9:8e:e5:33:eb:46:19:b8:de:b4:d0:6c -----BEGIN CERTIFICATE----- MIIDfDCCAmSgAwIBAgIQGKy1av1pthU6Y2yv2vrEoTANBgkqhkiG9w0BAQUFADBY MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjExMC8GA1UEAxMo R2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEx MjcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQK Ew1HZW9UcnVzdCBJbmMuMTEwLwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRp ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC AQEAvrgVe//UfH1nrYNke8hCUy3f9oQIIGHWAVlqnEQRr+92/ZV+zmEwu3qDXwK9 AWbK7hWNb6EwnL2hhZ6UOvNWiAAxz9juapYC2e0DjPt1befquFUWBRaa9OBesYjA ZIVcFU2Ix7e64HXprQU9nceJSOC7KMgD4TCTZF5SwFlwIjVXiIrxlQqD17wxcwE0 7e9GceBrAqg1cmuXm2bgyxx5X9gaBGgeRwLmnWDiNpcB3841kt++Z8dtd1k7j53W kBWUvEI0EME5+bEnPn7WinXFsq+W06Lem+SYvn3h6YGttm/81w7a4DSwDRp35+MI mO9Y+pyEtzavwt+s0vQQBnBxNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQULNVQQZcVi/CPNmFbSvtr2ZnJM5IwDQYJ KoZIhvcNAQEFBQADggEBAFpwfyzdtzRP9YZRqSa+S7iq8XEN3GHHoOo0Hnp3DwQ1 6CePbJC/kRYkRj5KTs4rFtULUh38H2eiAkUxT87z+gOneZ1TatnaYzr4gNfTmeGl 4b7UVXGYNTq+k+qurUKykG/g/CFNNWMziUnWm07Kx+dOCQD32sfvmWKZd7aVIl6K oKv0uHiYyjgZmclynnjNS6yvGaBzEi38wkG6gZHaFloxt/m0cYASSJlyc1pZU8Fj UjPtp8nSOQJw+uCxQmYpqptR7TBUIhRf2asdweSU8Pj1K/fqynhG1riR/aYNKxoU AT6A8EKglQdebc3MS6RFjasS6LPeWuWgfOgPIh1a6Vk= -----END CERTIFICATE----- # Issuer: CN=thawte Primary Root CA O=thawte, Inc. OU=Certification Services Division/(c) 2006 thawte, Inc. - For authorized use only # Subject: CN=thawte Primary Root CA O=thawte, Inc. OU=Certification Services Division/(c) 2006 thawte, Inc. - For authorized use only # Label: "thawte Primary Root CA" # Serial: 69529181992039203566298953787712940909 # MD5 Fingerprint: 8c:ca:dc:0b:22:ce:f5:be:72:ac:41:1a:11:a8:d8:12 # SHA1 Fingerprint: 91:c6:d6:ee:3e:8a:c8:63:84:e5:48:c2:99:29:5c:75:6c:81:7b:81 # SHA256 Fingerprint: 8d:72:2f:81:a9:c1:13:c0:79:1d:f1:36:a2:96:6d:b2:6c:95:0a:97:1d:b4:6b:41:99:f4:ea:54:b7:8b:fb:9f -----BEGIN CERTIFICATE----- MIIEIDCCAwigAwIBAgIQNE7VVyDV7exJ9C/ON9srbTANBgkqhkiG9w0BAQUFADCB qTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw MDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxHzAdBgNV BAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwHhcNMDYxMTE3MDAwMDAwWhcNMzYw NzE2MjM1OTU5WjCBqTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5j LjEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYG A1UECxMvKGMpIDIwMDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNl IG9ubHkxHzAdBgNVBAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwggEiMA0GCSqG SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsoPD7gFnUnMekz52hWXMJEEUMDSxuaPFs W0hoSVk3/AszGcJ3f8wQLZU0HObrTQmnHNK4yZc2AreJ1CRfBsDMRJSUjQJib+ta 3RGNKJpchJAQeg29dGYvajig4tVUROsdB58Hum/u6f1OCyn1PoSgAfGcq/gcfomk 6KHYcWUNo1F77rzSImANuVud37r8UVsLr5iy6S7pBOhih94ryNdOwUxkHt3Ph1i6 Sk/KaAcdHJ1KxtUvkcx8cXIcxcBn6zL9yZJclNqFwJu/U30rCfSMnZEfl2pSy94J NqR32HuHUETVPm4pafs5SSYeCaWAe0At6+gnhcn+Yf1+5nyXHdWdAgMBAAGjQjBA MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBR7W0XP r87Lev0xkhpqtvNG61dIUDANBgkqhkiG9w0BAQUFAAOCAQEAeRHAS7ORtvzw6WfU DW5FvlXok9LOAz/t2iWwHVfLHjp2oEzsUHboZHIMpKnxuIvW1oeEuzLlQRHAd9mz YJ3rG9XRbkREqaYB7FViHXe4XI5ISXycO1cRrK1zN44veFyQaEfZYGDm/Ac9IiAX xPcW6cTYcvnIc3zfFi8VqT79aie2oetaupgf1eNNZAqdE8hhuvU5HIe6uL17In/2 /qxAeeWsEG89jxt5dovEN7MhGITlNgDrYyCZuen+MwS7QcjBAvlEYyCegc5C09Y/ LHbTY5xZ3Y+m4Q6gLkH3LpVHz7z9M/P2C2F+fpErgUfCJzDupxBdN49cOSvkBPB7 jVaMaA== -----END CERTIFICATE----- # Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G5 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2006 VeriSign, Inc. - For authorized use only # Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G5 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2006 VeriSign, Inc. - For authorized use only # Label: "VeriSign Class 3 Public Primary Certification Authority - G5" # Serial: 33037644167568058970164719475676101450 # MD5 Fingerprint: cb:17:e4:31:67:3e:e2:09:fe:45:57:93:f3:0a:fa:1c # SHA1 Fingerprint: 4e:b6:d5:78:49:9b:1c:cf:5f:58:1e:ad:56:be:3d:9b:67:44:a5:e5 # SHA256 Fingerprint: 9a:cf:ab:7e:43:c8:d8:80:d0:6b:26:2a:94:de:ee:e4:b4:65:99:89:c3:d0:ca:f1:9b:af:64:05:e4:1a:b7:df -----BEGIN CERTIFICATE----- MIIE0zCCA7ugAwIBAgIQGNrRniZ96LtKIVjNzGs7SjANBgkqhkiG9w0BAQUFADCB yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0 aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMzYwNzE2MjM1OTU5WjCByjEL MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJpU2ln biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y aXR5IC0gRzUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvJAgIKXo1 nmAMqudLO07cfLw8RRy7K+D+KQL5VwijZIUVJ/XxrcgxiV0i6CqqpkKzj/i5Vbex t0uz/o9+B1fs70PbZmIVYc9gDaTY3vjgw2IIPVQT60nKWVSFJuUrjxuf6/WhkcIz SdhDY2pSS9KP6HBRTdGJaXvHcPaz3BJ023tdS1bTlr8Vd6Gw9KIl8q8ckmcY5fQG BO+QueQA5N06tRn/Arr0PO7gi+s3i+z016zy9vA9r911kTMZHRxAy3QkGSGT2RT+ rCpSx4/VBEnkjWNHiDxpg8v+R70rfk/Fla4OndTRQ8Bnc+MUCH7lP59zuDMKz10/ NIeWiu5T6CUVAgMBAAGjgbIwga8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8E BAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJaW1hZ2UvZ2lmMCEwHzAH BgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYjaHR0cDovL2xvZ28udmVy aXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFH/TZafC3ey78DAJ80M5+gKv MzEzMA0GCSqGSIb3DQEBBQUAA4IBAQCTJEowX2LP2BqYLz3q3JktvXf2pXkiOOzE p6B4Eq1iDkVwZMXnl2YtmAl+X6/WzChl8gGqCBpH3vn5fJJaCGkgDdk+bW48DW7Y 5gaRQBi5+MHt39tBquCWIMnNZBU4gcmU7qKEKQsTb47bDN0lAtukixlE0kF6BWlK WE9gyn6CagsCqiUXObXbf+eEZSqVir2G3l6BFoMtEMze/aiCKm0oHw0LxOXnGiYZ 4fQRbxC1lfznQgUy286dUV4otp6F01vvpX1FQHKOtw5rDgb7MzVIcbidJ4vEZV8N hnacRHr2lVz2XTIIM6RUthg/aFzyQkqFOFSDX9HoLPKsEdao7WNq -----END CERTIFICATE----- # Issuer: CN=COMODO Certification Authority O=COMODO CA Limited # Subject: CN=COMODO Certification Authority O=COMODO CA Limited # Label: "COMODO Certification Authority" # Serial: 104350513648249232941998508985834464573 # MD5 Fingerprint: 5c:48:dc:f7:42:72:ec:56:94:6d:1c:cc:71:35:80:75 # SHA1 Fingerprint: 66:31:bf:9e:f7:4f:9e:b6:c9:d5:a6:0c:ba:6a:be:d1:f7:bd:ef:7b # SHA256 Fingerprint: 0c:2c:d6:3d:f7:80:6f:a3:99:ed:e8:09:11:6b:57:5b:f8:79:89:f0:65:18:f9:80:8c:86:05:03:17:8b:af:66 -----BEGIN CERTIFICATE----- MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0 aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3 UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI 2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8 Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp +2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+ DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW /zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/ RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4 zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB ZQ== -----END CERTIFICATE----- # Issuer: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C. # Subject: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C. # Label: "Network Solutions Certificate Authority" # Serial: 116697915152937497490437556386812487904 # MD5 Fingerprint: d3:f3:a6:16:c0:fa:6b:1d:59:b1:2d:96:4d:0e:11:2e # SHA1 Fingerprint: 74:f8:a3:c3:ef:e7:b3:90:06:4b:83:90:3c:21:64:60:20:e5:df:ce # SHA256 Fingerprint: 15:f0:ba:00:a3:ac:7a:f3:ac:88:4c:07:2b:10:11:a0:77:bd:77:c0:97:f4:01:64:b2:f8:59:8a:bd:83:86:0c -----BEGIN CERTIFICATE----- MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4 qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8 6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/ h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH /nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey -----END CERTIFICATE----- # Issuer: CN=COMODO ECC Certification Authority O=COMODO CA Limited # Subject: CN=COMODO ECC Certification Authority O=COMODO CA Limited # Label: "COMODO ECC Certification Authority" # Serial: 41578283867086692638256921589707938090 # MD5 Fingerprint: 7c:62:ff:74:9d:31:53:5e:68:4a:d5:78:aa:1e:bf:23 # SHA1 Fingerprint: 9f:74:4e:9f:2b:4d:ba:ec:0f:31:2c:50:b6:56:3b:8e:2d:93:c3:11 # SHA256 Fingerprint: 17:93:92:7a:06:14:54:97:89:ad:ce:2f:8f:34:f7:f0:b6:6d:0f:3a:e3:a3:b8:4d:21:ec:15:db:ba:4f:ad:c7 -----BEGIN CERTIFICATE----- MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY= -----END CERTIFICATE----- # Issuer: CN=TC TrustCenter Class 2 CA II O=TC TrustCenter GmbH OU=TC TrustCenter Class 2 CA # Subject: CN=TC TrustCenter Class 2 CA II O=TC TrustCenter GmbH OU=TC TrustCenter Class 2 CA # Label: "TC TrustCenter Class 2 CA II" # Serial: 941389028203453866782103406992443 # MD5 Fingerprint: ce:78:33:5c:59:78:01:6e:18:ea:b9:36:a0:b9:2e:23 # SHA1 Fingerprint: ae:50:83:ed:7c:f4:5c:bc:8f:61:c6:21:fe:68:5d:79:42:21:15:6e # SHA256 Fingerprint: e6:b8:f8:76:64:85:f8:07:ae:7f:8d:ac:16:70:46:1f:07:c0:a1:3e:ef:3a:1f:f7:17:53:8d:7a:ba:d3:91:b4 -----BEGIN CERTIFICATE----- MIIEqjCCA5KgAwIBAgIOLmoAAQACH9dSISwRXDswDQYJKoZIhvcNAQEFBQAwdjEL MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxIjAgBgNV BAsTGVRDIFRydXN0Q2VudGVyIENsYXNzIDIgQ0ExJTAjBgNVBAMTHFRDIFRydXN0 Q2VudGVyIENsYXNzIDIgQ0EgSUkwHhcNMDYwMTEyMTQzODQzWhcNMjUxMjMxMjI1 OTU5WjB2MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIgR21i SDEiMCAGA1UECxMZVEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQTElMCMGA1UEAxMc VEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQSBJSTCCASIwDQYJKoZIhvcNAQEBBQAD ggEPADCCAQoCggEBAKuAh5uO8MN8h9foJIIRszzdQ2Lu+MNF2ujhoF/RKrLqk2jf tMjWQ+nEdVl//OEd+DFwIxuInie5e/060smp6RQvkL4DUsFJzfb95AhmC1eKokKg uNV/aVyQMrKXDcpK3EY+AlWJU+MaWss2xgdW94zPEfRMuzBwBJWl9jmM/XOBCH2J XjIeIqkiRUuwZi4wzJ9l/fzLganx4Duvo4bRierERXlQXa7pIXSSTYtZgo+U4+lK 8edJsBTj9WLL1XK9H7nSn6DNqPoByNkN39r8R52zyFTfSUrxIan+GE7uSNQZu+99 5OKdy1u2bv/jzVrndIIFuoAlOMvkaZ6vQaoahPUCAwEAAaOCATQwggEwMA8GA1Ud EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTjq1RMgKHbVkO3 kUrL84J6E1wIqzCB7QYDVR0fBIHlMIHiMIHfoIHcoIHZhjVodHRwOi8vd3d3LnRy dXN0Y2VudGVyLmRlL2NybC92Mi90Y19jbGFzc18yX2NhX0lJLmNybIaBn2xkYXA6 Ly93d3cudHJ1c3RjZW50ZXIuZGUvQ049VEMlMjBUcnVzdENlbnRlciUyMENsYXNz JTIwMiUyMENBJTIwSUksTz1UQyUyMFRydXN0Q2VudGVyJTIwR21iSCxPVT1yb290 Y2VydHMsREM9dHJ1c3RjZW50ZXIsREM9ZGU/Y2VydGlmaWNhdGVSZXZvY2F0aW9u TGlzdD9iYXNlPzANBgkqhkiG9w0BAQUFAAOCAQEAjNfffu4bgBCzg/XbEeprS6iS GNn3Bzn1LL4GdXpoUxUc6krtXvwjshOg0wn/9vYua0Fxec3ibf2uWWuFHbhOIprt ZjluS5TmVfwLG4t3wVMTZonZKNaL80VKY7f9ewthXbhtvsPcW3nS7Yblok2+XnR8 au0WOB9/WIFaGusyiC2y8zl3gK9etmF1KdsjTYjKUCjLhdLTEKJZbtOTVAB6okaV hgWcqRmY5TFyDADiZ9lA4CQze28suVyrZZ0srHbqNZn1l7kPJOzHdiEoZa5X6AeI dUpWoNIFOqTmjZKILPPy4cHGYdtBxceb9w4aUUXCYWvcZCcXjFq32nQozZfkvQ== -----END CERTIFICATE----- # Issuer: CN=TC TrustCenter Class 3 CA II O=TC TrustCenter GmbH OU=TC TrustCenter Class 3 CA # Subject: CN=TC TrustCenter Class 3 CA II O=TC TrustCenter GmbH OU=TC TrustCenter Class 3 CA # Label: "TC TrustCenter Class 3 CA II" # Serial: 1506523511417715638772220530020799 # MD5 Fingerprint: 56:5f:aa:80:61:12:17:f6:67:21:e6:2b:6d:61:56:8e # SHA1 Fingerprint: 80:25:ef:f4:6e:70:c8:d4:72:24:65:84:fe:40:3b:8a:8d:6a:db:f5 # SHA256 Fingerprint: 8d:a0:84:fc:f9:9c:e0:77:22:f8:9b:32:05:93:98:06:fa:5c:b8:11:e1:c8:13:f6:a1:08:c7:d3:36:b3:40:8e -----BEGIN CERTIFICATE----- MIIEqjCCA5KgAwIBAgIOSkcAAQAC5aBd1j8AUb8wDQYJKoZIhvcNAQEFBQAwdjEL MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxIjAgBgNV BAsTGVRDIFRydXN0Q2VudGVyIENsYXNzIDMgQ0ExJTAjBgNVBAMTHFRDIFRydXN0 Q2VudGVyIENsYXNzIDMgQ0EgSUkwHhcNMDYwMTEyMTQ0MTU3WhcNMjUxMjMxMjI1 OTU5WjB2MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIgR21i SDEiMCAGA1UECxMZVEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMyBDQTElMCMGA1UEAxMc VEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMyBDQSBJSTCCASIwDQYJKoZIhvcNAQEBBQAD ggEPADCCAQoCggEBALTgu1G7OVyLBMVMeRwjhjEQY0NVJz/GRcekPewJDRoeIMJW Ht4bNwcwIi9v8Qbxq63WyKthoy9DxLCyLfzDlml7forkzMA5EpBCYMnMNWju2l+Q Vl/NHE1bWEnrDgFPZPosPIlY2C8u4rBo6SI7dYnWRBpl8huXJh0obazovVkdKyT2 1oQDZogkAHhg8fir/gKya/si+zXmFtGt9i4S5Po1auUZuV3bOx4a+9P/FRQI2Alq ukWdFHlgfa9Aigdzs5OW03Q0jTo3Kd5c7PXuLjHCINy+8U9/I1LZW+Jk2ZyqBwi1 Rb3R0DHBq1SfqdLDYmAD8bs5SpJKPQq5ncWg/jcCAwEAAaOCATQwggEwMA8GA1Ud EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTUovyfs8PYA9NX XAek0CSnwPIA1DCB7QYDVR0fBIHlMIHiMIHfoIHcoIHZhjVodHRwOi8vd3d3LnRy dXN0Y2VudGVyLmRlL2NybC92Mi90Y19jbGFzc18zX2NhX0lJLmNybIaBn2xkYXA6 Ly93d3cudHJ1c3RjZW50ZXIuZGUvQ049VEMlMjBUcnVzdENlbnRlciUyMENsYXNz JTIwMyUyMENBJTIwSUksTz1UQyUyMFRydXN0Q2VudGVyJTIwR21iSCxPVT1yb290 Y2VydHMsREM9dHJ1c3RjZW50ZXIsREM9ZGU/Y2VydGlmaWNhdGVSZXZvY2F0aW9u TGlzdD9iYXNlPzANBgkqhkiG9w0BAQUFAAOCAQEANmDkcPcGIEPZIxpC8vijsrlN irTzwppVMXzEO2eatN9NDoqTSheLG43KieHPOh6sHfGcMrSOWXaiQYUlN6AT0PV8 TtXqluJucsG7Kv5sbviRmEb8yRtXW+rIGjs/sFGYPAfaLFkB2otE6OF0/ado3VS6 g0bsyEa1+K+XwDsJHI/OcpY9M1ZwvJbL2NV9IJqDnxrcOfHFcqMRA/07QlIp2+gB 95tejNaNhk4Z+rwcvsUhpYeeeC422wlxo3I0+GzjBgnyXlal092Y+tTmBvTwtiBj S+opvaqCZh77gaqnN60TGOaSw4HBM7uIHqHn4rS9MWwOUT1v+5ZWgOI2F9Hc5A== -----END CERTIFICATE----- # Issuer: CN=TC TrustCenter Universal CA I O=TC TrustCenter GmbH OU=TC TrustCenter Universal CA # Subject: CN=TC TrustCenter Universal CA I O=TC TrustCenter GmbH OU=TC TrustCenter Universal CA # Label: "TC TrustCenter Universal CA I" # Serial: 601024842042189035295619584734726 # MD5 Fingerprint: 45:e1:a5:72:c5:a9:36:64:40:9e:f5:e4:58:84:67:8c # SHA1 Fingerprint: 6b:2f:34:ad:89:58:be:62:fd:b0:6b:5c:ce:bb:9d:d9:4f:4e:39:f3 # SHA256 Fingerprint: eb:f3:c0:2a:87:89:b1:fb:7d:51:19:95:d6:63:b7:29:06:d9:13:ce:0d:5e:10:56:8a:8a:77:e2:58:61:67:e7 -----BEGIN CERTIFICATE----- MIID3TCCAsWgAwIBAgIOHaIAAQAC7LdggHiNtgYwDQYJKoZIhvcNAQEFBQAweTEL MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxJDAiBgNV BAsTG1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQTEmMCQGA1UEAxMdVEMgVHJ1 c3RDZW50ZXIgVW5pdmVyc2FsIENBIEkwHhcNMDYwMzIyMTU1NDI4WhcNMjUxMjMx MjI1OTU5WjB5MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIg R21iSDEkMCIGA1UECxMbVEMgVHJ1c3RDZW50ZXIgVW5pdmVyc2FsIENBMSYwJAYD VQQDEx1UQyBUcnVzdENlbnRlciBVbml2ZXJzYWwgQ0EgSTCCASIwDQYJKoZIhvcN AQEBBQADggEPADCCAQoCggEBAKR3I5ZEr5D0MacQ9CaHnPM42Q9e3s9B6DGtxnSR JJZ4Hgmgm5qVSkr1YnwCqMqs+1oEdjneX/H5s7/zA1hV0qq34wQi0fiU2iIIAI3T fCZdzHd55yx4Oagmcw6iXSVphU9VDprvxrlE4Vc93x9UIuVvZaozhDrzznq+VZeu jRIPFDPiUHDDSYcTvFHe15gSWu86gzOSBnWLknwSaHtwag+1m7Z3W0hZneTvWq3z wZ7U10VOylY0Ibw+F1tvdwxIAUMpsN0/lm7mlaoMwCC2/T42J5zjXM9OgdwZu5GQ fezmlwQek8wiSdeXhrYTCjxDI3d+8NzmzSQfO4ObNDqDNOMCAwEAAaNjMGEwHwYD VR0jBBgwFoAUkqR1LKSevoFE63n8isWVpesQdXMwDwYDVR0TAQH/BAUwAwEB/zAO BgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFJKkdSyknr6BROt5/IrFlaXrEHVzMA0G CSqGSIb3DQEBBQUAA4IBAQAo0uCG1eb4e/CX3CJrO5UUVg8RMKWaTzqwOuAGy2X1 7caXJ/4l8lfmXpWMPmRgFVp/Lw0BxbFg/UU1z/CyvwbZ71q+s2IhtNerNXxTPqYn 8aEt2hojnczd7Dwtnic0XQ/CNnm8yUpiLe1r2X1BQ3y2qsrtYbE3ghUJGooWMNjs ydZHcnhLEEYUjl8Or+zHL6sQ17bxbuyGssLoDZJz3KL0Dzq/YSMQiZxIQG5wALPT ujdEWBF6AmqI8Dc08BnprNRlc/ZpjGSUOnmFKbAWKwyCPwacx/0QK54PLLae4xW/ 2TYcuiUaUj0a7CIMHOCkoj3w6DnPgcB77V0fb8XQC9eY -----END CERTIFICATE----- # Issuer: CN=Cybertrust Global Root O=Cybertrust, Inc # Subject: CN=Cybertrust Global Root O=Cybertrust, Inc # Label: "Cybertrust Global Root" # Serial: 4835703278459682877484360 # MD5 Fingerprint: 72:e4:4a:87:e3:69:40:80:77:ea:bc:e3:f4:ff:f0:e1 # SHA1 Fingerprint: 5f:43:e5:b1:bf:f8:78:8c:ac:1c:c7:ca:4a:9a:c6:22:2b:cc:34:c6 # SHA256 Fingerprint: 96:0a:df:00:63:e9:63:56:75:0c:29:65:dd:0a:08:67:da:0b:9c:bd:6e:77:71:4a:ea:fb:23:49:ab:39:3d:a3 -----BEGIN CERTIFICATE----- MIIDoTCCAomgAwIBAgILBAAAAAABD4WqLUgwDQYJKoZIhvcNAQEFBQAwOzEYMBYG A1UEChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2Jh bCBSb290MB4XDTA2MTIxNTA4MDAwMFoXDTIxMTIxNTA4MDAwMFowOzEYMBYGA1UE ChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2JhbCBS b290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+Mi8vRRQZhP/8NN5 7CPytxrHjoXxEnOmGaoQ25yiZXRadz5RfVb23CO21O1fWLE3TdVJDm71aofW0ozS J8bi/zafmGWgE07GKmSb1ZASzxQG9Dvj1Ci+6A74q05IlG2OlTEQXO2iLb3VOm2y HLtgwEZLAfVJrn5GitB0jaEMAs7u/OePuGtm839EAL9mJRQr3RAwHQeWP032a7iP t3sMpTjr3kfb1V05/Iin89cqdPHoWqI7n1C6poxFNcJQZZXcY4Lv3b93TZxiyWNz FtApD0mpSPCzqrdsxacwOUBdrsTiXSZT8M4cIwhhqJQZugRiQOwfOHB3EgZxpzAY XSUnpQIDAQABo4GlMIGiMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/ MB0GA1UdDgQWBBS2CHsNesysIEyGVjJez6tuhS1wVzA/BgNVHR8EODA2MDSgMqAw hi5odHRwOi8vd3d3Mi5wdWJsaWMtdHJ1c3QuY29tL2NybC9jdC9jdHJvb3QuY3Js MB8GA1UdIwQYMBaAFLYIew16zKwgTIZWMl7Pq26FLXBXMA0GCSqGSIb3DQEBBQUA A4IBAQBW7wojoFROlZfJ+InaRcHUowAl9B8Tq7ejhVhpwjCt2BWKLePJzYFa+HMj Wqd8BfP9IjsO0QbE2zZMcwSO5bAi5MXzLqXZI+O4Tkogp24CJJ8iYGd7ix1yCcUx XOl5n4BHPa2hCwcUPUf/A2kaDAtE52Mlp3+yybh2hO0j9n0Hq0V+09+zv+mKts2o omcrUtW3ZfA5TGOgkXmTUg9U3YO7n9GPp1Nzw8v/MOx8BLjYRB+TX3EJIrduPuoc A06dGiBh+4E37F78CkWr1+cXVdCg6mCbpvbjjFspwgZgFJ0tl0ypkxWdYcQBX0jW WL1WMRJOEcgh4LMRkWXbtKaIOM5V -----END CERTIFICATE----- # Issuer: CN=GeoTrust Primary Certification Authority - G3 O=GeoTrust Inc. OU=(c) 2008 GeoTrust Inc. - For authorized use only # Subject: CN=GeoTrust Primary Certification Authority - G3 O=GeoTrust Inc. OU=(c) 2008 GeoTrust Inc. - For authorized use only # Label: "GeoTrust Primary Certification Authority - G3" # Serial: 28809105769928564313984085209975885599 # MD5 Fingerprint: b5:e8:34:36:c9:10:44:58:48:70:6d:2e:83:d4:b8:05 # SHA1 Fingerprint: 03:9e:ed:b8:0b:e7:a0:3c:69:53:89:3b:20:d2:d9:32:3a:4c:2a:fd # SHA256 Fingerprint: b4:78:b8:12:25:0d:f8:78:63:5c:2a:a7:ec:7d:15:5e:aa:62:5e:e8:29:16:e2:cd:29:43:61:88:6c:d1:fb:d4 -----BEGIN CERTIFICATE----- MIID/jCCAuagAwIBAgIQFaxulBmyeUtB9iepwxgPHzANBgkqhkiG9w0BAQsFADCB mDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsT MChjKSAyMDA4IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s eTE2MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhv cml0eSAtIEczMB4XDTA4MDQwMjAwMDAwMFoXDTM3MTIwMTIzNTk1OVowgZgxCzAJ BgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykg MjAwOCBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0 BgNVBAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANziXmJYHTNXOTIz +uvLh4yn1ErdBojqZI4xmKU4kB6Yzy5jK/BGvESyiaHAKAxJcCGVn2TAppMSAmUm hsalifD614SgcK9PGpc/BkTVyetyEH3kMSj7HGHmKAdEc5IiaacDiGydY8hS2pgn 5whMcD60yRLBxWeDXTPzAxHsatBT4tG6NmCUgLthY2xbF37fQJQeqw3CIShwiP/W JmxsYAQlTlV+fe+/lEjetx3dcI0FX4ilm/LC7urRQEFtYjgdVgbFA0dRIBn8exAL DmKudlW/X3e+PkkBUz2YJQN2JFodtNuJ6nnltrM7P7pMKEF/BqxqjsHQ9gUdfeZC huOl1UcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw HQYDVR0OBBYEFMR5yo6hTgMdHNxr2zFblD4/MH8tMA0GCSqGSIb3DQEBCwUAA4IB AQAtxRPPVoB7eni9n64smefv2t+UXglpp+duaIy9cr5HqQ6XErhK8WTTOd8lNNTB zU6B8A8ExCSzNJbGpqow32hhc9f5joWJ7w5elShKKiePEI4ufIbEAp7aDHdlDkQN kv39sxY2+hENHYwOB4lqKVb3cvTdFZx3NWZXqxNT2I7BQMXXExZacse3aQHEerGD AWh9jUGhlBjBJVz88P6DAod8DQ3PLghcSkANPuyBYeYk28rgDi0Hsj5W3I31QYUH SJsMC8tJP33st/3LjWeJGqvtux6jAAgIFyqCXDFdRootD4abdNlF+9RAsXqqaC2G spki4cErx5z481+oghLrGREt -----END CERTIFICATE----- # Issuer: CN=thawte Primary Root CA - G2 O=thawte, Inc. OU=(c) 2007 thawte, Inc. - For authorized use only # Subject: CN=thawte Primary Root CA - G2 O=thawte, Inc. OU=(c) 2007 thawte, Inc. - For authorized use only # Label: "thawte Primary Root CA - G2" # Serial: 71758320672825410020661621085256472406 # MD5 Fingerprint: 74:9d:ea:60:24:c4:fd:22:53:3e:cc:3a:72:d9:29:4f # SHA1 Fingerprint: aa:db:bc:22:23:8f:c4:01:a1:27:bb:38:dd:f4:1d:db:08:9e:f0:12 # SHA256 Fingerprint: a4:31:0d:50:af:18:a6:44:71:90:37:2a:86:af:af:8b:95:1f:fb:43:1d:83:7f:1e:56:88:b4:59:71:ed:15:57 -----BEGIN CERTIFICATE----- MIICiDCCAg2gAwIBAgIQNfwmXNmET8k9Jj1Xm67XVjAKBggqhkjOPQQDAzCBhDEL MAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjE4MDYGA1UECxMvKGMp IDIwMDcgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAi BgNVBAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMjAeFw0wNzExMDUwMDAw MDBaFw0zODAxMTgyMzU5NTlaMIGEMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhh d3RlLCBJbmMuMTgwNgYDVQQLEy8oYykgMjAwNyB0aGF3dGUsIEluYy4gLSBGb3Ig YXV0aG9yaXplZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9v dCBDQSAtIEcyMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEotWcgnuVnfFSeIf+iha/ BebfowJPDQfGAFG6DAJSLSKkQjnE/o/qycG+1E3/n3qe4rF8mq2nhglzh9HnmuN6 papu+7qzcMBniKI11KOasf2twu8x+qi58/sIxpHR+ymVo0IwQDAPBgNVHRMBAf8E BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUmtgAMADna3+FGO6Lts6K DPgR4bswCgYIKoZIzj0EAwMDaQAwZgIxAN344FdHW6fmCsO99YCKlzUNG4k8VIZ3 KMqh9HneteY4sPBlcIx/AlTCv//YoT7ZzwIxAMSNlPzcU9LcnXgWHxUzI1NS41ox XZ3Krr0TKUQNJ1uo52icEvdYPy5yAlejj6EULg== -----END CERTIFICATE----- # Issuer: CN=thawte Primary Root CA - G3 O=thawte, Inc. OU=Certification Services Division/(c) 2008 thawte, Inc. - For authorized use only # Subject: CN=thawte Primary Root CA - G3 O=thawte, Inc. OU=Certification Services Division/(c) 2008 thawte, Inc. - For authorized use only # Label: "thawte Primary Root CA - G3" # Serial: 127614157056681299805556476275995414779 # MD5 Fingerprint: fb:1b:5d:43:8a:94:cd:44:c6:76:f2:43:4b:47:e7:31 # SHA1 Fingerprint: f1:8b:53:8d:1b:e9:03:b6:a6:f0:56:43:5b:17:15:89:ca:f3:6b:f2 # SHA256 Fingerprint: 4b:03:f4:58:07:ad:70:f2:1b:fc:2c:ae:71:c9:fd:e4:60:4c:06:4c:f5:ff:b6:86:ba:e5:db:aa:d7:fd:d3:4c -----BEGIN CERTIFICATE----- MIIEKjCCAxKgAwIBAgIQYAGXt0an6rS0mtZLL/eQ+zANBgkqhkiG9w0BAQsFADCB rjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw MDggdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAiBgNV BAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMzAeFw0wODA0MDIwMDAwMDBa Fw0zNzEyMDEyMzU5NTlaMIGuMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3Rl LCBJbmMuMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9u MTgwNgYDVQQLEy8oYykgMjAwOCB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXpl ZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9vdCBDQSAtIEcz MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsr8nLPvb2FvdeHsbnndm gcs+vHyu86YnmjSjaDFxODNi5PNxZnmxqWWjpYvVj2AtP0LMqmsywCPLLEHd5N/8 YZzic7IilRFDGF/Eth9XbAoFWCLINkw6fKXRz4aviKdEAhN0cXMKQlkC+BsUa0Lf b1+6a4KinVvnSr0eAXLbS3ToO39/fR8EtCab4LRarEc9VbjXsCZSKAExQGbY2SS9 9irY7CFJXJv2eul/VTV+lmuNk5Mny5K76qxAwJ/C+IDPXfRa3M50hqY+bAtTyr2S zhkGcuYMXDhpxwTWvGzOW/b3aJzcJRVIiKHpqfiYnODz1TEoYRFsZ5aNOZnLwkUk OQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNV HQ4EFgQUrWyqlGCc7eT/+j4KdCtjA/e2Wb8wDQYJKoZIhvcNAQELBQADggEBABpA 2JVlrAmSicY59BDlqQ5mU1143vokkbvnRFHfxhY0Cu9qRFHqKweKA3rD6z8KLFIW oCtDuSWQP3CpMyVtRRooOyfPqsMpQhvfO0zAMzRbQYi/aytlryjvsvXDqmbOe1bu t8jLZ8HJnBoYuMTDSQPxYA5QzUbF83d597YV4Djbxy8ooAw/dyZ02SUS2jHaGh7c KUGRIjxpp7sC8rZcJwOJ9Abqm+RyguOhCcHpABnTPtRwa7pxpqpYrvS76Wy274fM m7v/OeZWYdMKp8RcTGB7BXcmer/YB1IsYvdwY9k5vG8cwnncdimvzsUsZAReiDZu MdRAGmI0Nj81Aa6sY6A= -----END CERTIFICATE----- # Issuer: CN=GeoTrust Primary Certification Authority - G2 O=GeoTrust Inc. OU=(c) 2007 GeoTrust Inc. - For authorized use only # Subject: CN=GeoTrust Primary Certification Authority - G2 O=GeoTrust Inc. OU=(c) 2007 GeoTrust Inc. - For authorized use only # Label: "GeoTrust Primary Certification Authority - G2" # Serial: 80682863203381065782177908751794619243 # MD5 Fingerprint: 01:5e:d8:6b:bd:6f:3d:8e:a1:31:f8:12:e0:98:73:6a # SHA1 Fingerprint: 8d:17:84:d5:37:f3:03:7d:ec:70:fe:57:8b:51:9a:99:e6:10:d7:b0 # SHA256 Fingerprint: 5e:db:7a:c4:3b:82:a0:6a:87:61:e8:d7:be:49:79:eb:f2:61:1f:7d:d7:9b:f9:1c:1c:6b:56:6a:21:9e:d7:66 -----BEGIN CERTIFICATE----- MIICrjCCAjWgAwIBAgIQPLL0SAoA4v7rJDteYD7DazAKBggqhkjOPQQDAzCBmDEL MAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsTMChj KSAyMDA3IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTE2 MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 eSAtIEcyMB4XDTA3MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVowgZgxCzAJBgNV BAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykgMjAw NyBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNV BAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH MjB2MBAGByqGSM49AgEGBSuBBAAiA2IABBWx6P0DFUPlrOuHNxFi79KDNlJ9RVcL So17VDs6bl8VAsBQps8lL33KSLjHUGMcKiEIfJo22Av+0SbFWDEwKCXzXV2juLal tJLtbCyf691DiaI8S0iRHVDsJt/WYC69IaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBVfNVdRVfslsq0DafwBo/q+EVXVMAoG CCqGSM49BAMDA2cAMGQCMGSWWaboCd6LuvpaiIjwH5HTRqjySkwCY/tsXzjbLkGT qQ7mndwxHLKgpxgceeHHNgIwOlavmnRs9vuD4DPTCF+hnMJbn0bWtsuRBmOiBucz rD6ogRLQy7rQkgu2npaqBA+K -----END CERTIFICATE----- # Issuer: CN=VeriSign Universal Root Certification Authority O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2008 VeriSign, Inc. - For authorized use only # Subject: CN=VeriSign Universal Root Certification Authority O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2008 VeriSign, Inc. - For authorized use only # Label: "VeriSign Universal Root Certification Authority" # Serial: 85209574734084581917763752644031726877 # MD5 Fingerprint: 8e:ad:b5:01:aa:4d:81:e4:8c:1d:d1:e1:14:00:95:19 # SHA1 Fingerprint: 36:79:ca:35:66:87:72:30:4d:30:a5:fb:87:3b:0f:a7:7b:b7:0d:54 # SHA256 Fingerprint: 23:99:56:11:27:a5:71:25:de:8c:ef:ea:61:0d:df:2f:a0:78:b5:c8:06:7f:4e:82:82:90:bf:b8:60:e8:4b:3c -----BEGIN CERTIFICATE----- MIIEuTCCA6GgAwIBAgIQQBrEZCGzEyEDDrvkEhrFHTANBgkqhkiG9w0BAQsFADCB vTELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwOCBWZXJp U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MTgwNgYDVQQDEy9W ZXJpU2lnbiBVbml2ZXJzYWwgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe Fw0wODA0MDIwMDAwMDBaFw0zNzEyMDEyMzU5NTlaMIG9MQswCQYDVQQGEwJVUzEX MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0 IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWduLCBJbmMuIC0gRm9y IGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVuaXZlcnNh bCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEF AAOCAQ8AMIIBCgKCAQEAx2E3XrEBNNti1xWb/1hajCMj1mCOkdeQmIN65lgZOIzF 9uVkhbSicfvtvbnazU0AtMgtc6XHaXGVHzk8skQHnOgO+k1KxCHfKWGPMiJhgsWH H26MfF8WIFFE0XBPV+rjHOPMee5Y2A7Cs0WTwCznmhcrewA3ekEzeOEz4vMQGn+H LL729fdC4uW/h2KJXwBL38Xd5HVEMkE6HnFuacsLdUYI0crSK5XQz/u5QGtkjFdN /BMReYTtXlT2NJ8IAfMQJQYXStrxHXpma5hgZqTZ79IugvHw7wnqRMkVauIDbjPT rJ9VAMf2CGqUuV/c4DPxhGD5WycRtPwW8rtWaoAljQIDAQABo4GyMIGvMA8GA1Ud EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMG0GCCsGAQUFBwEMBGEwX6FdoFsw WTBXMFUWCWltYWdlL2dpZjAhMB8wBwYFKw4DAhoEFI/l0xqGrI2Oa8PPgGrUSBgs exkuMCUWI2h0dHA6Ly9sb2dvLnZlcmlzaWduLmNvbS92c2xvZ28uZ2lmMB0GA1Ud DgQWBBS2d/ppSEefUxLVwuoHMnYH0ZcHGTANBgkqhkiG9w0BAQsFAAOCAQEASvj4 sAPmLGd75JR3Y8xuTPl9Dg3cyLk1uXBPY/ok+myDjEedO2Pzmvl2MpWRsXe8rJq+ seQxIcaBlVZaDrHC1LGmWazxY8u4TB1ZkErvkBYoH1quEPuBUDgMbMzxPcP1Y+Oz 4yHJJDnp/RVmRvQbEdBNc6N9Rvk97ahfYtTxP/jgdFcrGJ2BtMQo2pSXpXDrrB2+ BxHw1dvd5Yzw1TKwg+ZX4o+/vqGqvz0dtdQ46tewXDpPaj+PwGZsY6rp2aQW9IHR lRQOfc2VNNnSj3BzgXucfr2YYdhFh5iQxeuGMMY1v/D/w1WIg0vvBZIGcfK4mJO3 7M2CYfE45k+XmCpajQ== -----END CERTIFICATE----- # Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G4 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2007 VeriSign, Inc. - For authorized use only # Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G4 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2007 VeriSign, Inc. - For authorized use only # Label: "VeriSign Class 3 Public Primary Certification Authority - G4" # Serial: 63143484348153506665311985501458640051 # MD5 Fingerprint: 3a:52:e1:e7:fd:6f:3a:e3:6f:f3:6f:99:1b:f9:22:41 # SHA1 Fingerprint: 22:d5:d8:df:8f:02:31:d1:8d:f7:9d:b7:cf:8a:2d:64:c9:3f:6c:3a # SHA256 Fingerprint: 69:dd:d7:ea:90:bb:57:c9:3e:13:5d:c8:5e:a6:fc:d5:48:0b:60:32:39:bd:c4:54:fc:75:8b:2a:26:cf:7f:79 -----BEGIN CERTIFICATE----- MIIDhDCCAwqgAwIBAgIQL4D+I4wOIg9IZxIokYesszAKBggqhkjOPQQDAzCByjEL MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2ln biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y aXR5IC0gRzQwHhcNMDcxMTA1MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCByjELMAkG A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZWZXJp U2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2lnbiwg SW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2ln biBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5 IC0gRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASnVnp8Utpkmw4tXNherJI9/gHm GUo9FANL+mAnINmDiWn6VMaaGF5VKmTeBvaNSjutEDxlPZCIBIngMGGzrl0Bp3ve fLK+ymVhAIau2o970ImtTR1ZmkGxvEeA3J5iw/mjgbIwga8wDwYDVR0TAQH/BAUw AwEB/zAOBgNVHQ8BAf8EBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJ aW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYj aHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFLMW kf3upm7ktS5Jj4d4gYDs5bG1MAoGCCqGSM49BAMDA2gAMGUCMGYhDBgmYFo4e1ZC 4Kf8NoRRkSAsdk1DPcQdhCPQrNZ8NQbOzWm9kA3bbEhCHQ6qQgIxAJw9SDkjOVga FRJZap7v1VmyHVIsmXHNxynfGyphe3HR3vPA5Q06Sqotp9iGKt0uEA== -----END CERTIFICATE----- # Issuer: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority # Subject: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority # Label: "Verisign Class 3 Public Primary Certification Authority" # Serial: 80507572722862485515306429940691309246 # MD5 Fingerprint: ef:5a:f1:33:ef:f1:cd:bb:51:02:ee:12:14:4b:96:c4 # SHA1 Fingerprint: a1:db:63:93:91:6f:17:e4:18:55:09:40:04:15:c7:02:40:b0:ae:6b # SHA256 Fingerprint: a4:b6:b3:99:6f:c2:f3:06:b3:fd:86:81:bd:63:41:3d:8c:50:09:cc:4f:a3:29:c2:cc:f0:e2:fa:1b:14:03:05 -----BEGIN CERTIFICATE----- MIICPDCCAaUCEDyRMcsf9tAbDpq40ES/Er4wDQYJKoZIhvcNAQEFBQAwXzELMAkG A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2 MDEyOTAwMDAwMFoXDTI4MDgwMjIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G CSqGSIb3DQEBBQUAA4GBABByUqkFFBkyCEHwxWsKzH4PIRnN5GfcX6kb5sroc50i 2JhucwNhkcV8sEVAbkSdjbCxlnRhLQ2pRdKkkirWmnWXbj9T/UWZYB2oK0z5XqcJ 2HUw19JlYD1n1khVdWk/kfVIC0dpImmClr7JyDiGSnoscxlIaU5rfGW/D/xwzoiQ -----END CERTIFICATE----- # Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3 # Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3 # Label: "GlobalSign Root CA - R3" # Serial: 4835703278459759426209954 # MD5 Fingerprint: c5:df:b8:49:ca:05:13:55:ee:2d:ba:1a:c3:3e:b0:28 # SHA1 Fingerprint: d6:9b:56:11:48:f0:1c:77:c5:45:78:c1:09:26:df:5b:85:69:76:ad # SHA256 Fingerprint: cb:b5:22:d7:b7:f1:27:ad:6a:01:13:86:5b:df:1c:d4:10:2e:7d:07:59:af:63:5a:7c:f4:72:0d:c9:63:c5:3b -----BEGIN CERTIFICATE----- MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4 MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8 RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK 6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH WD9f -----END CERTIFICATE----- # Issuer: CN=TC TrustCenter Universal CA III O=TC TrustCenter GmbH OU=TC TrustCenter Universal CA # Subject: CN=TC TrustCenter Universal CA III O=TC TrustCenter GmbH OU=TC TrustCenter Universal CA # Label: "TC TrustCenter Universal CA III" # Serial: 2010889993983507346460533407902964 # MD5 Fingerprint: 9f:dd:db:ab:ff:8e:ff:45:21:5f:f0:6c:9d:8f:fe:2b # SHA1 Fingerprint: 96:56:cd:7b:57:96:98:95:d0:e1:41:46:68:06:fb:b8:c6:11:06:87 # SHA256 Fingerprint: 30:9b:4a:87:f6:ca:56:c9:31:69:aa:a9:9c:6d:98:88:54:d7:89:2b:d5:43:7e:2d:07:b2:9c:be:da:55:d3:5d -----BEGIN CERTIFICATE----- MIID4TCCAsmgAwIBAgIOYyUAAQACFI0zFQLkbPQwDQYJKoZIhvcNAQEFBQAwezEL MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxJDAiBgNV BAsTG1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQTEoMCYGA1UEAxMfVEMgVHJ1 c3RDZW50ZXIgVW5pdmVyc2FsIENBIElJSTAeFw0wOTA5MDkwODE1MjdaFw0yOTEy MzEyMzU5NTlaMHsxCzAJBgNVBAYTAkRFMRwwGgYDVQQKExNUQyBUcnVzdENlbnRl ciBHbWJIMSQwIgYDVQQLExtUQyBUcnVzdENlbnRlciBVbml2ZXJzYWwgQ0ExKDAm BgNVBAMTH1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQSBJSUkwggEiMA0GCSqG SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDC2pxisLlxErALyBpXsq6DFJmzNEubkKLF 5+cvAqBNLaT6hdqbJYUtQCggbergvbFIgyIpRJ9Og+41URNzdNW88jBmlFPAQDYv DIRlzg9uwliT6CwLOunBjvvya8o84pxOjuT5fdMnnxvVZ3iHLX8LR7PH6MlIfK8v zArZQe+f/prhsq75U7Xl6UafYOPfjdN/+5Z+s7Vy+EutCHnNaYlAJ/Uqwa1D7KRT yGG299J5KmcYdkhtWyUB0SbFt1dpIxVbYYqt8Bst2a9c8SaQaanVDED1M4BDj5yj dipFtK+/fz6HP3bFzSreIMUWWMv5G/UPyw0RUmS40nZid4PxWJ//AgMBAAGjYzBh MB8GA1UdIwQYMBaAFFbn4VslQ4Dg9ozhcbyO5YAvxEjiMA8GA1UdEwEB/wQFMAMB Af8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRW5+FbJUOA4PaM4XG8juWAL8RI 4jANBgkqhkiG9w0BAQUFAAOCAQEAg8ev6n9NCjw5sWi+e22JLumzCecYV42Fmhfz dkJQEw/HkG8zrcVJYCtsSVgZ1OK+t7+rSbyUyKu+KGwWaODIl0YgoGhnYIg5IFHY aAERzqf2EQf27OysGh+yZm5WZ2B6dF7AbZc2rrUNXWZzwCUyRdhKBgePxLcHsU0G DeGl6/R1yrqc0L2z0zIkTO5+4nYES0lT2PLpVDP85XEfPRRclkvxOvIAu2y0+pZV CIgJwcyRGSmwIC3/yzikQOEXvnlhgP8HA4ZMTnsGnxGGjYnuJ8Tb4rwZjgvDwxPH LQNjO9Po5KIqwoIIlBZU8O8fJ5AluA0OKBtHd0e9HKgl8ZS0Zg== -----END CERTIFICATE----- # Issuer: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc. # Subject: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc. # Label: "Go Daddy Root Certificate Authority - G2" # Serial: 0 # MD5 Fingerprint: 80:3a:bc:22:c1:e6:fb:8d:9b:3b:27:4a:32:1b:9a:01 # SHA1 Fingerprint: 47:be:ab:c9:22:ea:e8:0e:78:78:34:62:a7:9f:45:c2:54:fd:e6:8b # SHA256 Fingerprint: 45:14:0b:32:47:eb:9c:c8:c5:b4:f0:d7:b5:30:91:f7:32:92:08:9e:6e:5a:63:e2:74:9d:d3:ac:a9:19:8e:da -----BEGIN CERTIFICATE----- MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH /PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu 9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo 2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI 4uJEvlz36hz1 -----END CERTIFICATE----- # Issuer: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc. # Subject: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc. # Label: "Starfield Root Certificate Authority - G2" # Serial: 0 # MD5 Fingerprint: d6:39:81:c6:52:7e:96:69:fc:fc:ca:66:ed:05:f2:96 # SHA1 Fingerprint: b5:1c:06:7c:ee:2b:0c:3d:f8:55:ab:2d:92:f4:fe:39:d4:e7:0f:0e # SHA256 Fingerprint: 2c:e1:cb:0b:f9:d2:f9:e1:02:99:3f:be:21:51:52:c3:b2:dd:0c:ab:de:1c:68:e5:31:9b:83:91:54:db:b7:f5 -----BEGIN CERTIFICATE----- MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6 b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1 HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0 HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3 4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg 8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1 mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0 -----END CERTIFICATE----- # Issuer: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc. # Subject: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc. # Label: "Starfield Services Root Certificate Authority - G2" # Serial: 0 # MD5 Fingerprint: 17:35:74:af:7b:61:1c:eb:f4:f9:3c:e2:ee:40:f9:a2 # SHA1 Fingerprint: 92:5a:8f:8d:2c:6d:04:e0:66:5f:59:6a:ff:22:d8:63:e8:25:6f:3f # SHA256 Fingerprint: 56:8d:69:05:a2:c8:87:08:a4:b3:02:51:90:ed:cf:ed:b1:97:4a:60:6a:13:c6:e5:29:0f:cb:2a:e6:3e:da:b5 -----BEGIN CERTIFICATE----- MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5 MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2 8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk 6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn 0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN sSi6 -----END CERTIFICATE----- # Issuer: CN=AffirmTrust Commercial O=AffirmTrust # Subject: CN=AffirmTrust Commercial O=AffirmTrust # Label: "AffirmTrust Commercial" # Serial: 8608355977964138876 # MD5 Fingerprint: 82:92:ba:5b:ef:cd:8a:6f:a6:3d:55:f9:84:f6:d6:b7 # SHA1 Fingerprint: f9:b5:b6:32:45:5f:9c:be:ec:57:5f:80:dc:e9:6e:2c:c7:b2:78:b7 # SHA256 Fingerprint: 03:76:ab:1d:54:c5:f9:80:3c:e4:b2:e2:01:a0:ee:7e:ef:7b:57:b6:36:e8:a9:3c:9b:8d:48:60:c9:6f:5f:a7 -----BEGIN CERTIFICATE----- MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1 yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/ nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8= -----END CERTIFICATE----- # Issuer: CN=AffirmTrust Networking O=AffirmTrust # Subject: CN=AffirmTrust Networking O=AffirmTrust # Label: "AffirmTrust Networking" # Serial: 8957382827206547757 # MD5 Fingerprint: 42:65:ca:be:01:9a:9a:4c:a9:8c:41:49:cd:c0:d5:7f # SHA1 Fingerprint: 29:36:21:02:8b:20:ed:02:f5:66:c5:32:d1:d6:ed:90:9f:45:00:2f # SHA256 Fingerprint: 0a:81:ec:5a:92:97:77:f1:45:90:4a:f3:8d:5d:50:9f:66:b5:e2:c5:8f:cd:b5:31:05:8b:0e:17:f3:f0:b4:1b -----BEGIN CERTIFICATE----- MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp 6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48 x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s= -----END CERTIFICATE----- # Issuer: CN=AffirmTrust Premium O=AffirmTrust # Subject: CN=AffirmTrust Premium O=AffirmTrust # Label: "AffirmTrust Premium" # Serial: 7893706540734352110 # MD5 Fingerprint: c4:5d:0e:48:b6:ac:28:30:4e:0a:bc:f9:38:16:87:57 # SHA1 Fingerprint: d8:a6:33:2c:e0:03:6f:b1:85:f6:63:4f:7d:6a:06:65:26:32:28:27 # SHA256 Fingerprint: 70:a7:3f:7f:37:6b:60:07:42:48:90:45:34:b1:14:82:d5:bf:0e:69:8e:cc:49:8d:f5:25:77:eb:f2:e9:3b:9a -----BEGIN CERTIFICATE----- MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ +jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5 HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7 70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S 5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/ BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2 KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B 8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc 0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8 GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e KeC2uAloGRwYQw== -----END CERTIFICATE----- # Issuer: CN=AffirmTrust Premium ECC O=AffirmTrust # Subject: CN=AffirmTrust Premium ECC O=AffirmTrust # Label: "AffirmTrust Premium ECC" # Serial: 8401224907861490260 # MD5 Fingerprint: 64:b0:09:55:cf:b1:d5:99:e2:be:13:ab:a6:5d:ea:4d # SHA1 Fingerprint: b8:23:6b:00:2f:1d:16:86:53:01:55:6c:11:a4:37:ca:eb:ff:c3:bb # SHA256 Fingerprint: bd:71:fd:f6:da:97:e4:cf:62:d1:64:7a:dd:25:81:b0:7d:79:ad:f8:39:7e:b4:ec:ba:9c:5e:84:88:82:14:23 -----BEGIN CERTIFICATE----- MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D 0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9 ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ== -----END CERTIFICATE----- # Issuer: CN=StartCom Certification Authority O=StartCom Ltd. OU=Secure Digital Certificate Signing # Subject: CN=StartCom Certification Authority O=StartCom Ltd. OU=Secure Digital Certificate Signing # Label: "StartCom Certification Authority" # Serial: 45 # MD5 Fingerprint: c9:3b:0d:84:41:fc:a4:76:79:23:08:57:de:10:19:16 # SHA1 Fingerprint: a3:f1:33:3f:e2:42:bf:cf:c5:d1:4e:8f:39:42:98:40:68:10:d1:a0 # SHA256 Fingerprint: e1:78:90:ee:09:a3:fb:f4:f4:8b:9c:41:4a:17:d6:37:b7:a5:06:47:e9:bc:75:23:22:72:7f:cc:17:42:a9:11 -----BEGIN CERTIFICATE----- MIIHhzCCBW+gAwIBAgIBLTANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJJTDEW MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM3WhcNMzYwOTE3MTk0NjM2WjB9 MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w +2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B 26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID AQABo4ICEDCCAgwwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD VR0OBBYEFE4L7xqkQFulF2mHMMo0aEPQQa7yMB8GA1UdIwQYMBaAFE4L7xqkQFul F2mHMMo0aEPQQa7yMIIBWgYDVR0gBIIBUTCCAU0wggFJBgsrBgEEAYG1NwEBATCC ATgwLgYIKwYBBQUHAgEWImh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL3BvbGljeS5w ZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL2ludGVybWVk aWF0ZS5wZGYwgc8GCCsGAQUFBwICMIHCMCcWIFN0YXJ0IENvbW1lcmNpYWwgKFN0 YXJ0Q29tKSBMdGQuMAMCAQEagZZMaW1pdGVkIExpYWJpbGl0eSwgcmVhZCB0aGUg c2VjdGlvbiAqTGVnYWwgTGltaXRhdGlvbnMqIG9mIHRoZSBTdGFydENvbSBDZXJ0 aWZpY2F0aW9uIEF1dGhvcml0eSBQb2xpY3kgYXZhaWxhYmxlIGF0IGh0dHA6Ly93 d3cuc3RhcnRzc2wuY29tL3BvbGljeS5wZGYwEQYJYIZIAYb4QgEBBAQDAgAHMDgG CWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNTTCBDZXJ0aWZpY2F0aW9uIEF1 dGhvcml0eTANBgkqhkiG9w0BAQsFAAOCAgEAjo/n3JR5fPGFf59Jb2vKXfuM/gTF wWLRfUKKvFO3lANmMD+x5wqnUCBVJX92ehQN6wQOQOY+2IirByeDqXWmN3PH/UvS Ta0XQMhGvjt/UfzDtgUx3M2FIk5xt/JxXrAaxrqTi3iSSoX4eA+D/i+tLPfkpLst 0OcNOrg+zvZ49q5HJMqjNTbOx8aHmNrs++myziebiMMEofYLWWivydsQD032ZGNc pRJvkrKTlMeIFw6Ttn5ii5B/q06f/ON1FE8qMt9bDeD1e5MNq6HPh+GlBEXoPBKl CcWw0bdT82AUuoVpaiF8H3VhFyAXe2w7QSlc4axa0c2Mm+tgHRns9+Ww2vl5GKVF P0lDV9LdJNUso/2RjSe15esUBppMeyG7Oq0wBhjA2MFrLH9ZXF2RsXAiV+uKa0hK 1Q8p7MZAwC+ITGgBF3f0JBlPvfrhsiAhS90a2Cl9qrjeVOwhVYBsHvUwyKMQ5bLm KhQxw4UtjJixhlpPiVktucf3HMiKf8CdBUrmQk9io20ppB+Fq9vlgcitKj1MXVuE JnHEhV5xJMqlG2zYYdMa4FTbzrqpMrUi9nNBCV24F10OD5mQ1kfabwo6YigUZ4LZ 8dCAWZvLMdibD4x3TrVoivJs9iQOLWxwxXPR3hTQcY+203sC9uO41Alua551hDnm fyWl8kgAwKQB2j8= -----END CERTIFICATE----- # Issuer: CN=StartCom Certification Authority G2 O=StartCom Ltd. # Subject: CN=StartCom Certification Authority G2 O=StartCom Ltd. # Label: "StartCom Certification Authority G2" # Serial: 59 # MD5 Fingerprint: 78:4b:fb:9e:64:82:0a:d3:b8:4c:62:f3:64:f2:90:64 # SHA1 Fingerprint: 31:f1:fd:68:22:63:20:ee:c6:3b:3f:9d:ea:4a:3e:53:7c:7c:39:17 # SHA256 Fingerprint: c7:ba:65:67:de:93:a7:98:ae:1f:aa:79:1e:71:2d:37:8f:ae:1f:93:c4:39:7f:ea:44:1b:b7:cb:e6:fd:59:95 -----BEGIN CERTIFICATE----- MIIFYzCCA0ugAwIBAgIBOzANBgkqhkiG9w0BAQsFADBTMQswCQYDVQQGEwJJTDEW MBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoGA1UEAxMjU3RhcnRDb20gQ2VydGlm aWNhdGlvbiBBdXRob3JpdHkgRzIwHhcNMTAwMTAxMDEwMDAxWhcNMzkxMjMxMjM1 OTAxWjBTMQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoG A1UEAxMjU3RhcnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgRzIwggIiMA0G CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2iTZbB7cgNr2Cu+EWIAOVeq8Oo1XJ JZlKxdBWQYeQTSFgpBSHO839sj60ZwNq7eEPS8CRhXBF4EKe3ikj1AENoBB5uNsD vfOpL9HG4A/LnooUCri99lZi8cVytjIl2bLzvWXFDSxu1ZJvGIsAQRSCb0AgJnoo D/Uefyf3lLE3PbfHkffiAez9lInhzG7TNtYKGXmu1zSCZf98Qru23QumNK9LYP5/ Q0kGi4xDuFby2X8hQxfqp0iVAXV16iulQ5XqFYSdCI0mblWbq9zSOdIxHWDirMxW RST1HFSr7obdljKF+ExP6JV2tgXdNiNnvP8V4so75qbsO+wmETRIjfaAKxojAuuK HDp2KntWFhxyKrOq42ClAJ8Em+JvHhRYW6Vsi1g8w7pOOlz34ZYrPu8HvKTlXcxN nw3h3Kq74W4a7I/htkxNeXJdFzULHdfBR9qWJODQcqhaX2YtENwvKhOuJv4KHBnM 0D4LnMgJLvlblnpHnOl68wVQdJVznjAJ85eCXuaPOQgeWeU1FEIT/wCc976qUM/i UUjXuG+v+E5+M5iSFGI6dWPPe/regjupuznixL0sAA7IF6wT700ljtizkC+p2il9 Ha90OrInwMEePnWjFqmveiJdnxMaz6eg6+OGCtP95paV1yPIN93EfKo2rJgaErHg TuixO/XWb/Ew1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQE AwIBBjAdBgNVHQ4EFgQUS8W0QGutHLOlHGVuRjaJhwUMDrYwDQYJKoZIhvcNAQEL BQADggIBAHNXPyzVlTJ+N9uWkusZXn5T50HsEbZH77Xe7XRcxfGOSeD8bpkTzZ+K 2s06Ctg6Wgk/XzTQLwPSZh0avZyQN8gMjgdalEVGKua+etqhqaRpEpKwfTbURIfX UfEpY9Z1zRbkJ4kd+MIySP3bmdCPX1R0zKxnNBFi2QwKN4fRoxdIjtIXHfbX/dtl 6/2o1PXWT6RbdejF0mCy2wl+JYt7ulKSnj7oxXehPOBKc2thz4bcQ///If4jXSRK 9dNtD2IEBVeC2m6kMyV5Sy5UGYvMLD0w6dEG/+gyRr61M3Z3qAFdlsHB1b6uJcDJ HgoJIIihDsnzb02CVAAgp9KP5DlUFy6NHrgbuxu9mk47EDTcnIhT76IxW1hPkWLI wpqazRVdOKnWvvgTtZ8SafJQYqz7Fzf07rh1Z2AQ+4NQ+US1dZxAF7L+/XldblhY XzD8AK6vM8EOTmy6p6ahfzLbOOCxchcKK5HsamMm7YnUeMx0HgX4a/6ManY5Ka5l IxKVCCIcl85bBu4M4ru8H0ST9tg4RQUh7eStqxK2A6RCLi3ECToDZ2mEmuFZkIoo hdVddLHRDiBYmxOlsGOm7XtH/UVVMKTumtTm4ofvmMkyghEpIrwACjFeLQ/Ajulr so8uBtjRkcfGEvRM/TAXw8HaOFvjqermobp573PYtlNXLfbQ4ddI -----END CERTIFICATE----- github_api-0.18.2/lib/github_api/client/0000755000004100000410000000000013214644262020110 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/git_data.rb0000644000004100000410000000103713214644262022212 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::GitData < API require_all 'github_api/client/git_data', 'blobs', 'commits', 'references', 'tags', 'trees' # Access to GitData::Blobs API namespace :blobs # Access to GitData::Commits API namespace :commits # Access to GitData::References API namespace :references # Access to GitData::Tags API namespace :tags # Access to GitData::Tags API namespace :trees end # GitData end # Github github_api-0.18.2/lib/github_api/client/pull_requests/0000755000004100000410000000000013214644262023017 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/pull_requests/comments.rb0000644000004100000410000001074513214644262025200 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::PullRequests::Comments < API # List comments on a pull request # # @example # github = Github.new # github.pull_requests.comments.list 'user-name', 'repo-name', number: 'id' # # List comments in a repository # # By default, Review Comments are ordered by ascending ID. # # @param [Hash] params # @input params [String] :sort # Optional string. Can be either created or updated. Default: created # @input params [String] :direction # Optional string. Can be either asc or desc. Ignored without sort parameter # @input params [String] :since # Optional string of a timestamp in ISO 8601 # format: YYYY-MM-DDTHH:MM:SSZ # @example # github = Github.new # github.pull_requests.comments.list 'user-name', 'repo-name' # github.pull_requests.comments.list 'user-name', 'repo-name' { |comm| ... } # # @api public def list(*args) arguments(args, required: [:user, :repo]) params = arguments.params user = arguments.user repo = arguments.repo response = if (number = params.delete('number')) get_request("/repos/#{user}/#{repo}/pulls/#{number}/comments", params) else get_request("/repos/#{user}/#{repo}/pulls/comments", params) end return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get a single comment for pull requests # # @example # github = Github.new # github.pull_requests.comments.get 'user-name', 'repo-name', 'number' # # @example # github.pull_requests.comments.get # user: 'user-name', # repo: 'repo-name', # number: 'comment-number # # @api public def get(*args) arguments(args, required: [:user, :repo, :number]) get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/comments", arguments.params) end alias_method :find, :get # Create a pull request comment # # @param [Hash] params # @option params [String] :body # Required string. The text of the comment. # @option params [String] :commit_id # Required string - The SHA of the commit to comment on. # @option params [String] :path # Required string. The relative path of the file to comment on. # @option params [Number] :position # Required number. The line index in the diff to comment on. # # @example # github = Github.new # github.pull_requests.comments.create 'user-name', 'repo-name', 'number', # body: "Nice change", # commit_id: "6dcb09b5b57875f334f61aebed695e2e4193db5e", # path: "file1.txt", # position: 4 # # Alternative Inputs # # Instead of passing commit_id, path, and position you can reply to # an existing Pull Request Comment like this # @option params [String] :body # Required string. The text of the comment. # @option params [Number] :in_reply_to # Required number. The comment id to reply to. # # @example # github = Github.new # github.pull_requests.comments.create 'user-name','repo-name', 'number', # body: "Nice change", # in_reply_to: 4 # # @api public def create(*args) arguments(args, required: [:user, :repo, :number]) post_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/comments", arguments.params) end # Edit a pull request comment # # @param [Hash] params # @option params [String] :body # Required string. The text of the comment. # # @example # github = Github.new # github.pull_requests.comments.edit 'user-name', 'repo-name', 'number', # body: "Nice change" # # @api public def edit(*args) arguments(args, required: [:user, :repo, :number]) patch_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/comments/#{arguments.number}", arguments.params) end # Delete a pull request comment # # @example # github = Github.new # github.pull_requests.comments.delete 'user-name', 'repo-name', 'number' # # @api public def delete(*args) arguments(args, required: [:user, :repo, :number]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/comments/#{arguments.number}", arguments.params) end end # PullRequests::Comments end # Github github_api-0.18.2/lib/github_api/client/pull_requests/reviews.rb0000644000004100000410000001207013214644262025030 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::PullRequests::Reviews < API PREVIEW_MEDIA = "application/vnd.github.black-cat-preview+json".freeze # :nodoc: # List reviews on a pull request # # @example # github = Github.new # github.pull_requests.reviews.list 'user-name', 'repo-name', number: 'pull-request-number' # # List pull request reviews in a repository # # @example # github = Github.new # github.pull_requests.reviews.list 'user-name', 'repo-name', number: 'pull-request-number' # github.pull_requests.reviews.list 'user-name', 'repo-name', number: 'pull-request-number' { |comm| ... } # # @api public def list(*args) arguments(args, required: [:user, :repo, :number]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA response = get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/reviews", params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get a single review for pull requests # # @example # github = Github.new # github.pull_requests.reviews.get 'user-name', 'repo-name', 'number', 'id' # # @example # github.pull_requests.reviews.get # user: 'user-name', # repo: 'repo-name', # number: 1, # id: 80 # # @api public def get(*args) arguments(args, required: [:user, :repo, :number, :id]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/reviews/#{arguments.id}", params) end alias_method :find, :get # Create a pull request review # # @param [Hash] params # @option params [String] :event # Required string - The review action (event) to perform; can be one of # APPROVE, REQUEST_CHANGES, or COMMENT. If left blank, the API returns # HTTP 422 (Unrecognizable entity) and the review is left PENDING # @option params [String] :body # Optional string. The text of the review. # @option params [Array] :comments # Optional array of draft review comment objects. An array of comments # part of the review. # # @example # github = Github.new # github.pull_requests.reviews.create 'user-name', 'repo-name', 'number', # body: "Nice change", # event: "APPROVE", # comments: [ # { # path: 'path/to/file/commented/on', # position: 10, # body: 'This looks good.' # } # ] # # @api public def create(*args) arguments(args, required: [:user, :repo, :number]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA post_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/reviews", params) end # Update a pull request review # # @param [Hash] params # @option params [String] :state # Required string - The review action (event) to perform; can be one of # APPROVE, REQUEST_CHANGES, or COMMENT. If left blank, the API returns # HTTP 422 (Unrecognizable entity) and the review is left PENDING # @optoin params [String] :body # Optional string # # @example # github = Github.new oauth_token: '...' # github.pull_requests.reviews.update 'user-name', 'repo-name', 'number', 'review-id' # body: "Update body", # event: "APPROVE" # # @api public def update(*args) arguments(args, required: [:user, :repo, :number, :id]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA post_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/reviews/#{arguments.id}/events", params) end # @option params [String] :message # Optional string - Reason for dismissal # # @example # github = Github.new oauth_token: '...' # github.pull_requests.reviews.dismiss 'user-name', 'repo-name', 'number', 'review-id' # message: "I can't get to this right now." # # @api public def dismiss(*args) arguments(args, required: [:user, :repo, :number, :id]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA put_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/reviews/#{arguments.id}/dismissals", params) end # List comments on a pull request review # # @example # github = Github.new # github.pull_requests.revieiws.comments 'user-name', 'repo-name', 'number', 'review-id' # # @api public def comments(*args) arguments(args, required: [:user, :repo, :number, :id]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA response = get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/reviews/#{arguments.id}/comments", params) return response unless block_given? response.each { |el| yield el } end end end github_api-0.18.2/lib/github_api/client/gists/0000755000004100000410000000000013214644262021241 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/gists/comments.rb0000644000004100000410000000506213214644262023416 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Gists::Comments < API # List comments on a gist # # @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist # # @example # github = Github.new # github.gists.comments.list 'gist-id' # # @return [Hash] # # @api public def list(*args) arguments(args, required: [:gist_id]) response = get_request("/gists/#{arguments.gist_id}/comments", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get a single comment # # @see https://developer.github.com/v3/gists/comments/#get-a-single-comment # # @example # github = Github.new # github.gists.comments.get 'gist-id', 'comment-id' # # @api public def get(*args) arguments(args, required: [:gist_id, :id]) get_request("/gists/#{arguments.gist_id}/comments/#{arguments.id}", arguments.params) end alias_method :find, :get # Create a comment # # @see https://developer.github.com/v3/gists/comments/#create-a-comment # # @param [Hash] params # @option params [String] :body # Required. The comment text. # # @example # github = Github.new # github.gists.comments.create 'gist-id' # # @api public def create(*args) arguments(args, required: [:gist_id]) post_request("/gists/#{arguments.gist_id}/comments", arguments.params) end # Edit a comment # # @see https://developer.github.com/v3/gists/comments/#edit-a-comment # # @param [Hash] params # @option params [String] :body # Required. The comment text. # # @example # github = Github.new # github.gists.comments.edit 'gist-id', 'comment-id' # # @api public def edit(*args) arguments(args, required: [:gist_id, :id]) patch_request("/gists/#{arguments.gist_id}/comments/#{arguments.id}", arguments.params) end # Delete a comment # # @see https://developer.github.com/v3/gists/comments/#delete-a-comment # # @xample # github = Github.new # github.gists.comments.delete 'gist-id', 'comment-id' # # @api public def delete(*args) arguments(args, required: [:gist_id, :id]) delete_request("/gists/#{arguments.gist_id}/comments/#{arguments.id}", arguments.params) end end # Gists::Comments end # Github github_api-0.18.2/lib/github_api/client/meta.rb0000644000004100000410000000053013214644262021361 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Meta < API # Get meta information about GitHub.com, the service. # # @example # Github.meta.get # # @api public def get(*args) arguments(*args) get_request("/meta", arguments.params) end end # Client::Meta end # Github github_api-0.18.2/lib/github_api/client/repos.rb0000644000004100000410000003324413214644262021573 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Repos < API # Load all the modules after initializing Repos to avoid superclass mismatch require_all 'github_api/client/repos', 'branches', 'collaborators', 'comments', 'commits', 'contents', 'deployments', 'downloads', 'forks', 'hooks', 'keys', 'merging', 'pages', 'projects', 'pub_sub_hubbub', 'releases', 'statistics', 'statuses' REQUIRED_REPO_OPTIONS = %w[ name ] VALID_REPO_OPTIONS = %w[ name description homepage private has_issues has_wiki has_downloads team_id auto_init gitignore_template default_branch ].freeze VALID_REPO_TYPES = %w[ all public private member ].freeze # Access to Repos::Collaborators API namespace :collaborators # Access to Repos::Comments API namespace :comments # Access to Repos::Commits API namespace :commits # Access to Repos::Contents API namespace :contents # Access to Repos::Deployments API namespace :deployments # Access to Repos::Downloads API namespace :downloads # Access to Repos::Forks API namespace :forks # Access to Repos::Hooks API namespace :hooks # Access to Repos::Keys API namespace :keys # Access to Repos::Merging API namespace :merging # Access to Repos::Pages API namespace :pages # Access to Repos::Projects API namespace :projects # Access to Repos::PubSubHubbub API namespace :pubsubhubbub, full_name: :pub_sub_hubbub # Access to Repos::Releases API namespace :releases # Access to Repos::Statistics API namespace :stats, full_name: :statistics # Access to Repos::Statuses API namespace :statuses # Access to Repos::Branches API namespace :branches # List repositories for the authenticated user # # @example # github = Github.new oauth_token: '...' # github.repos.list # github.repos.list { |repo| ... } # # List all repositories # # This provides a dump of every repository, # in the order that they were created. # # @param [Hash] params # @option params [Integer] :since # the integer ID of the last Repository that you've seen. # # @example # github = Github.new # github.repos.list :every # github.repos.list :every { |repo| ... } # # List public repositories for the specified user. # # @example # github = Github.new # github.repos.list user: 'user-name' # github.repos.list user: 'user-name', { |repo| ... } # # List repositories for the specified organisation. # # @example # github = Github.new # github.repos.list org: 'org-name' # github.repos.list org: 'org-name', { |repo| ... } # # @api public def list(*args) arguments(args) do permit %w[ user org type sort direction since ] end params = arguments.params unless params.symbolize_keys[:per_page] params.merge!(Pagination.per_page_as_param(current_options[:per_page])) end response = if (user_name = params.delete('user') || user) get_request("/users/#{user_name}/repos", params) elsif (org_name = params.delete('org') || org) get_request("/orgs/#{org_name}/repos", params) elsif args.map(&:to_s).include?('every') get_request('/repositories', params) else # For authenticated user get_request('/user/repos', params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a repository # # @example # github = Github.new # github.repos.get 'user-name', 'repo-name' # github.repos.get user: 'user-name', repo: 'repo-name' # github.repos(user: 'user-name', repo: 'repo-name').get # def get(*args) arguments(args, required: [:user, :repo]) get_request("/repos/#{arguments.user}/#{arguments.repo}", arguments.params) end alias :find :get # Get a repository # # @example # github = Github.new # github.repos.get_by_id 'repo-id' # github.repos.get_by_id id: 'repo-id' # github.repos(id: 'repo-id').get_by_id # def get_by_id(*args) arguments(args, required: [:id]) get_request("/repositories/#{arguments.id}", arguments.params) end alias :find_by_id :get_by_id # Create a new repository for the autheticated user. # # @param [Hash] params # @option params [String] :name # Required string # @option params [String] :description # Optional string # @option params [String] :homepage # Optional string # @option params [Boolean] :private # Optional boolean - true to create a private repository, # false to create a public one. # @option params [Boolean] :has_issues # Optional boolean - true to enable issues for this repository, # false to disable them # @option params [Boolean] :has_wiki # Optional boolean - true to enable the wiki for this repository, # false to disable it. Default is true # @option params [Boolean] :has_downloads # Optional boolean - true to enable downloads for this repository # @option params [String] :org # Optional string - The organisation in which this # repository will be created # @option params [Numeric] :team_id # Optional number - The id of the team that will be granted # access to this repository. This is only valid when creating # a repo in an organization # @option params [Boolean] :auto_init # Optional boolean - true to create an initial commit with # empty README. Default is false. # @option params [String] :gitignore_template # Optional string - Desired language or platform .gitignore # template to apply. Use the name of the template without # the extension. For example, “Haskell” Ignored if # auto_init parameter is not provided. # # @example # github = Github.new # github.repos.create "name": 'repo-name' # "description": "This is your first repo", # "homepage": "https://github.com", # "private": false, # "has_issues": true, # "has_wiki": true, # "has_downloads": true # # Create a new repository in this organisation. The authenticated user # must be a member of this organisation # # @example # github = Github.new oauth_token: '...' # github.repos.create name: 'repo-name', org: 'organisation-name' # # @example def create(*args) arguments(args) do assert_required %w[ name ] end params = arguments.params # Requires authenticated user if (org = params.delete('org') || org) post_request("/orgs/#{org}/repos", params) else post_request("/user/repos", params) end end # Delete a repository # # Deleting a repository requires admin access. # If OAuth is used, the delete_repo scope is required. # # @example # github = Github.new oauth_token: '...' # github.repos.delete 'user-name', 'repo-name' # # @api public def delete(*args) arguments(args, required: [:user, :repo]) delete_request("/repos/#{arguments.user}/#{arguments.repo}", arguments.params) end alias :remove :delete # List contributors # # @param [Hash] params # @option params [Boolean] :anon # Optional flag. Set to 1 or true to include anonymous contributors. # # @examples # github = Github.new # github.repos.contributors 'user-name','repo-name' # github.repos.contributors 'user-name','repo-name' { |cont| ... } # # @api public def contributors(*args) arguments(args, required: [:user, :repo]) do permit %w[ anon ] end response = get_request("/repos/#{arguments.user}/#{arguments.repo}/contributors", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :list_contributors :contributors alias :contribs :contributors # Edit a repository # # @param [Hash] params # @option params [String] :name # Required string # @option params [String] :description # Optional string # @option params [String] :homepage # Optional string # @option params [Boolean] :private # Optional boolean, true to make this a private repository, false to make it a public one # @option params [Boolean] :has_issues # Optional boolean - true to enable issues for this repository, # false to disable them # @option params [Boolean] :has_wiki # Optional boolean - true to enable the wiki for this repository, # false to disable it. Default is true # @option params [Boolean] :has_downloads # Optional boolean - true to enable downloads for this repository # @option params [String] :default_branch # Optional string - Update the default branch for this repository. # # @example # github = Github.new # github.repos.edit 'user-name', 'repo-name', # name: 'hello-world', # description: 'This is your first repo', # homepage: "https://github.com", # public: true, has_issues: true # def edit(*args) arguments(args, required: [:user, :repo]) do permit VALID_REPO_OPTIONS assert_required %w[ name ] end patch_request("/repos/#{arguments.user}/#{arguments.repo}", arguments.params) end # Delete a repository # # Deleting a repository requires admin access. # If OAuth is used, the delete_repo scope is required. # # @example # github = Github.new oauth_token: '...' # github.repos.delete 'user-name', 'repo-name' # # @api public def delete(*args) arguments(args, required: [:user, :repo]) delete_request("/repos/#{arguments.user}/#{arguments.repo}", arguments.params) end alias :remove :delete # List branches # # @example # github = Github.new # github.repos.branches 'user-name', 'repo-name' # github.repos(user: 'user-name', repo: 'repo-name').branches # # @example # repos = Github::Repos.new # repos.branches 'user-name', 'repo-name' # # @api public # def branches(*args) # arguments(args, required: [:user, :repo]) # response = get_request("/repos/#{arguments.user}/#{arguments.repo}/branches", arguments.params) # return response unless block_given? # response.each { |el| yield el } # end # alias :list_branches :branches # Get branch # # @example # github = Github.new # github.repos.branch 'user-name', 'repo-name', 'branch-name' # github.repos.branch user: 'user-name', repo: 'repo-name', branch: 'branch-name' # github.repos(user: 'user-name', repo: 'repo-name', branch: 'branch-name').branch # @api public # def branch(*args) # arguments(args, required: [:user, :repo, :branch]) # get_request("/repos/#{arguments.user}/#{arguments.repo}/branches/#{arguments.branch}", arguments.params) # end # List contributors # # @param [Hash] params # @option params [Boolean] :anon # Optional flag. Set to 1 or true to include anonymous contributors. # # @example # github = Github.new # github.repos.contributors 'user-name','repo-name' # github.repos.contributors 'user-name','repo-name' { |cont| ... } # # @api public def contributors(*args) arguments(args, required: [:user, :repo]) do permit ['anon'] end response = get_request("/repos/#{arguments.user}/#{arguments.repo}/contributors", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :list_contributors :contributors alias :contribs :contributors # List languages # # @examples # github = Github.new # github.repos.languages 'user-name', 'repo-name' # github.repos.languages 'user-name', 'repo-name' { |lang| ... } # # @api public def languages(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/languages", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :list_languages :languages # List tags # # @example # github = Github.new # github.repos.tags 'user-name', 'repo-name' # github.repos.tags 'user-name', 'repo-name' { |tag| ... } # # @api public def tags(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/tags", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :list_tags :tags alias :repo_tags :tags alias :repository_tags :tags # List teams # # @example # github = Github.new # github.repos.teams 'user-name', 'repo-name' # github.repos.teams 'user-name', 'repo-name' { |team| ... } # # @example # github.repos(user: 'user-name, repo: 'repo-name').teams # # @api public def teams(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/teams", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :list_teams :teams alias :repo_teams :teams alias :repository_teams :teams end # Client::Repos end # Github github_api-0.18.2/lib/github_api/client/activity.rb0000644000004100000410000000110213214644262022263 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Activity < API require_all 'github_api/client/activity', 'events', 'notifications', 'feeds', 'starring', 'watching' # Access to Activity::Events API namespace :events # Access to Activity::Notifications API namespace :notifications # Access to Activity::Feeds API namespace :feeds # Access to Activity::Starring API namespace :starring # Access to Activity::Watching API namespace :watching end # Activity end # Github github_api-0.18.2/lib/github_api/client/say.rb0000644000004100000410000000101213214644262021223 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Say < API # Generate ASCII octocat with speech bubble. # # @example # Github::Client::Say.new.say "My custom string..." # # @example # github = Github.new # github.octocat.say "My custom string..." # def say(*args) params = arguments(*args).params params[:s] = args.shift unless args.empty? params['raw'] = true get_request('/octocat', params) end end # Say end # Github github_api-0.18.2/lib/github_api/client/authorizations/0000755000004100000410000000000013214644262023173 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/authorizations/app.rb0000644000004100000410000000622413214644262024304 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Authorizations::App < Client::Authorizations # Get-or-create an authorization for a specific app # # @see https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app # # @param [Hash] params # @option params [String] client_secret # The 40 character OAuth app client secret associated with the client # ID specified in the URL. # @option params [Array] :scopes # Optional array - A list of scopes that this authorization is in. # @option params [String] :note # Optional string - A note to remind you what the OAuth token is for. # @option params [String] :note_url # Optional string - A URL to remind you what the OAuth token is for. # # @example # github = Github.new # github.oauth.app.create 'client-id', client_secret: '...' # # @api public def create(*args) raise_authentication_error unless authenticated? arguments(args, required: [:client_id]) if arguments.client_id put_request("/authorizations/clients/#{arguments.client_id}", arguments.params) else raise raise_app_authentication_error end end # Check if an access token is a valid authorization for an application # # @example # github = Github.new basic_auth: "client_id:client_secret" # github.oauth.app.check 'client_id', 'access-token' # # @api public def check(*args) raise_authentication_error unless authenticated? params = arguments(args, required: [:client_id, :access_token]).params if arguments.client_id begin get_request("/applications/#{arguments.client_id}/tokens/#{arguments.access_token}", params) rescue Github::Error::NotFound nil end else raise raise_app_authentication_error end end # Revoke all authorizations for an application # # @example # github = Github.new basic_auth: "client_id:client_secret" # github.oauth.app.delete 'client-id' # # Revoke an authorization for an application # # @example # github = Github.new basic_auth: "client_id:client_secret" # github.oauth.app.delete 'client-id', 'access-token' # # @api public def delete(*args) raise_authentication_error unless authenticated? params = arguments(args, required: [:client_id]).params if arguments.client_id if access_token = (params.delete('access_token') || args[1]) delete_request("/applications/#{arguments.client_id}/tokens/#{access_token}", params) else # Revokes all tokens delete_request("/applications/#{arguments.client_id}/tokens", params) end else raise raise_app_authentication_error end end alias :remove :delete alias :revoke :delete protected def raise_app_authentication_error raise ArgumentError, 'To create authorization for the app, ' + 'you need to provide client_id argument and client_secret parameter' end end # Client::Authorizations::App end # Github github_api-0.18.2/lib/github_api/client/orgs/0000755000004100000410000000000013214644262021062 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/orgs/teams.rb0000644000004100000410000003200113214644262022514 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # All actions against teams require at a minimum an authenticated user # who is a member of the owner's team in the :org being managed. # Api calls that require explicit permissions are noted. class Client::Orgs::Teams < API # List user teams # # List all of the teams across all of the organizations # to which the authenticated user belongs. This method # requires user or repo scope when authenticating via OAuth. # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.list # # List teams # # @see https://developer.github.com/v3/orgs/teams/#list-teams # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.list org: 'org-name' # # @api public def list(*args) params = arguments(args).params if (org = params.delete('org')) response = get_request("/orgs/#{org}/teams", params) else response = get_request('/user/teams', params) end return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get a team # # @see https://developer.github.com/v3/orgs/teams/#get-team # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.get 'team-id' # # @api public def get(*args) arguments(args, required: [:id]) get_request("/teams/#{arguments.id}", arguments.params) end alias_method :find, :get # Create a team # # In order to create a team, the authenticated user must be an owner of :org # # @see https://developer.github.com/v3/orgs/teams/#create-team # # @param [Hash] params # @option params [String] :name # Required. The name of the team # @option params [String] :description # The description of the team. # @option params [Array[String]] :repo_names # The repositories to add the team to. # @option params [String] :privacy # The level of privacy this team should have. Can be one of: # * secret - only visible to organization owners and # members of this team. # * closed - visible to all members of this organization. # Default: secret # @option params [String] :permission # The permission to grant the team. Can be one of: # * pull - team members can pull, but not push or # administor this repositories. # * push - team members can pull and push, # but not administor this repositores. # * admin - team members can pull, push and # administor these repositories. # Default: pull # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.create 'org-name', # name: "new team", # permission: "push", # repo_names: [ # "github/dotfiles" # ] # # @api public def create(*args) arguments(args, required: [:org_name]) do assert_required %w(name) end post_request("/orgs/#{arguments.org_name}/teams", arguments.params) end # Edit a team # # In order to edit a team, the authenticated user must be an owner # of the org that the team is associated with. # # @see https://developer.github.com/v3/orgs/teams/#edit-team # # @param [Hash] params # @option params [String] :name # The repositories to add the team to. # @option params [String] :description # The description of the team. # @option params [String] :privacy # The level of privacy this team should have. Can be one of: # * secret - only visible to organization owners and # members of this team. # * closed - visible to all members of this organization. # Default: secret # @option params [String] :permission # The permission to grant the team. Can be one of: # * pull - team members can pull, but not push or # administor this repositories. # * push - team members can pull and push, # but not administor this repositores. # * admin - team members can pull, push and # administor these repositories. # Default: pull # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.edit 'team-id', # name: "new team name", # permission: "push" # # @api public def edit(*args) arguments(args, required: [:id]) do assert_required %w(name) end patch_request("/teams/#{arguments.id}", arguments.params) end # Delete a team # # @see https://developer.github.com/v3/orgs/teams/#delete-team # # In order to delete a team, the authenticated user must be an owner # of the org that the team is associated with # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.delete 'team-id' # # @api public def delete(*args) arguments(args, required: [:id]) delete_request("/teams/#{arguments.id}", arguments.params) end alias_method :remove, :delete # List team members # # In order to list members in a team, the authenticated user # must be a member of the team. # # @see https://developer.github.com/v3/orgs/teams/#list-team-members # # @param [Integer] :team_id # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.list_members 'team-id' # github.orgs.teams.list_members 'team-id' { |member| ... } # # @api public def list_members(*args) arguments(args, required: [:team_id]) response = get_request("/teams/#{arguments.team_id}/members", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all_members, :list_members # Check if a user is a member of a team # # @see https://developer.github.com/v3/orgs/teams/#get-team-member # # @param [Integer] :team_id # @param [String] :username # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.team_member? 'team-id', 'user-name' # # @api public def team_member?(*args) arguments(args, required: [:team_id, :user]) response = get_request("/teams/#{arguments.team_id}/members/#{arguments.user}", arguments.params) response.status == 204 rescue Github::Error::NotFound false end # Add a team member # # In order to add a user to a team, the authenticated user must # have 'admin' permissions to the team or be an owner of the org # that the team is associated with. # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.add_member 'team-id', 'user-name' # # @api public def add_member(*args) arguments(args, required: [:id, :user]) put_request("/teams/#{arguments.id}/members/#{arguments.user}", arguments.params) end alias_method :add_team_member, :add_member # Remove a team member # # @see https://developer.github.com/v3/orgs/teams/#remove-team-member # # In order to remove a user from a team, the authenticated user must # have 'admin' permissions to the team or be an owner of the org that # the team is associated with. # note: This does not delete the user, it just remove them from the team. # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.remove_member 'team-id', 'user-name' # # @api public def remove_member(*args) arguments(args, required: [:id, :user]) delete_request("/teams/#{arguments.id}/members/#{arguments.user}", arguments.params) end alias_method :remove_team_member, :remove_member # Get team membership # # In order to get a user's membership with a team, # the team must be visible to the authenticated user. # # @see https://developer.github.com/v3/orgs/teams/#get-team-membership # # @param [Integer] :team_id # @param [String] :username # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.team_membership 'team-id', 'username' # # @api public def team_membership(*args) arguments(args, required: [:team_id, :username]) get_request("/teams/#{arguments.team_id}/memberships/#{arguments.username}", arguments.params) end # Add a team membership # # In order to add a user to a team, the authenticated user must # have 'admin' permissions to the team or be an owner of the org # that the team is associated with. # # @see https://developer.github.com/v3/orgs/teams/#add-team-membership # # @param [Integer] :team_id # @param [String] :username # @param [Hash] :params # @option params [String] :role # The role that this user should have in the team. Can be one of: # * member - a normal member of the team. # * maintainer - a team maintainer. Able to add/remove # other team members, promote other team members to # team maintainer, and edit the team's name and description. # Default: member # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.add_membership 'team-id', 'user-name' # # @api public def add_membership(*args) arguments(args, required: [:team_id, :user]) put_request("/teams/#{arguments.team_id}/memberships/#{arguments.user}", arguments.params) end alias_method :add_team_membership, :add_membership # Remove a team membership # # In order to remove a user from a team, the authenticated user must # have 'admin' permissions to the team or be an owner of the org that # the team is associated with. # note: This does not delete the user, it just remove them from the team. # # @see https://developer.github.com/v3/orgs/teams/#remove-team-membership # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.remove_membership 'team-id', 'user-name' # # @api public def remove_membership(*args) arguments(args, required: [:team_id, :user]) delete_request("/teams/#{arguments.team_id}/memberships/#{arguments.user}", arguments.params) end alias_method :remove_team_membership, :remove_membership # List team repositories # # @see https://developer.github.com/v3/orgs/teams/#list-team-repos # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.list_repos 'team-id' # # @api public def list_repos(*args) arguments(args, required: [:id]) response = get_request("/teams/#{arguments.id}/repos", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :repos, :list_repos # Check if a repository belongs to a team # # @see https://developer.github.com/v3/orgs/teams/#get-team-repo # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.team_repo? 'team-id', 'user-name', 'repo-name' # # @api public def team_repo?(*args) arguments(args, required: [:id, :user, :repo]) response = get_request("/teams/#{arguments.id}/repos/#{arguments.user}/#{arguments.repo}", arguments.params) response.status == 204 rescue Github::Error::NotFound false end alias_method :team_repository?, :team_repo? # Add a team repository # # In order to add a repo to a team, the authenticated user must be # an owner of the org that the team is associated with. Also, the repo # must be owned by the organization, or a direct for of a repo owned # by the organization. # # @see https://developer.github.com/v3/orgs/teams/#add-team-repo # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.add_repo 'team-id', 'user-name', 'repo-name' # # @api public def add_repo(*args) arguments(args, required: [:id, :user, :repo]) put_request("/teams/#{arguments.id}/repos/#{arguments.user}/#{arguments.repo}", arguments.params) end alias_method :add_repository, :add_repo # Remove a team repository # # In order to add a repo to a team, the authenticated user must be # an owner of the org that the team is associated with. # note: This does not delete the repo, it just removes it from the team. # # @see https://developer.github.com/v3/orgs/teams/#remove-team-repo # # @example # github = Github.new oauth_token: '...' # github.orgs.teams.remove_repo 'team-id', 'user-name', 'repo-name' # # @api public def remove_repo(*args) arguments(args, required: [:id, :user, :repo]) delete_request("/teams/#{arguments.id}/repos/#{arguments.user}/#{arguments.repo}", arguments.params) end alias_method :remove_repository, :remove_repo end # Client::Orgs::Teams end # Github github_api-0.18.2/lib/github_api/client/orgs/projects.rb0000644000004100000410000000317313214644262023244 0ustar www-datawww-data# frozen_string_literal: true require_relative '../../api' module Github class Client::Orgs::Projects < API PREVIEW_MEDIA = "application/vnd.github.inertia-preview+json".freeze # :nodoc: # List your organization projects # # @see List your organization projects # # @example # github = Github.new 'org-name' # github.orgs.projects.list 'org-name' { |project| ... } # # @example # github = Github.new # github.orgs.projects.list 'org-name', state: 'closed' # # @api public def list(*args) arguments(args, required: [:org_name]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA response = get_request("/orgs/#{arguments.org_name}/projects", params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Create a new project for the specified repo # # @param [Hash] params # @option params [String] :name # Required string - The name of the project. # @option params [String] :body # Optional string - The body of the project. # # @example # github = Github.new # github.repos.create 'owner-name', 'repo-name', name: 'project-name' # github.repos.create name: 'project-name', body: 'project-body', owner: 'owner-name', repo: 'repo-name' def create(*args) arguments(args, required: [:org_name]) do assert_required %w[ name ] end params = arguments.params params["accept"] ||= PREVIEW_MEDIA post_request("/orgs/#{arguments.org_name}/projects", params) end end # Projects end # Github github_api-0.18.2/lib/github_api/client/orgs/memberships.rb0000644000004100000410000000777313214644262023743 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Orgs::Memberships < API # List your organization memberships # # @see List your organization memberships # # @example # github = Github.new # github.orgs.memberships.list # # @api public def list(*args) arguments(args) response = get_request('/user/memberships/orgs', arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get organization membership # # In order to get a user's membership with an organization, # the authenticated user must be an organization owner. # # @see https://developer.github.com/v3/orgs/members/#get-organization-membership # @param [String] :org # @param [String] :username # # @example # github = Github.new oauth_toke: '...' # github.orgs.memberships.get 'orgname', username: 'piotr' # # Get your organization membership # # @see https://developer.github.com/v3/orgs/members/#get-your-organization-membership # # @example # github = Github.new oauth_token # github.orgs.memberships.get 'orgname' # # @api public def get(*args) arguments(args, required: [:org_name]) params = arguments.params if (username = params.delete('username')) get_request("/orgs/#{arguments.org_name}/memberships/#{username}", params) else get_request("/user/memberships/orgs/#{arguments.org_name}", params) end end alias_method :find, :get # Add/update user's membership with organization # # In order to create or update a user's membership with an organization, # the authenticated user must be an organization owner. # # @see https://developer.github.com/v3/orgs/members/#add-or-update-organization-membership # # @param [String] :org # @param [String] :username # @param [Hash] options # @option options [String] :role # Required. The role to give the user in the organization. Can be one of: # * admin - The user will become an owner of the organization. # * member - The user will become a non-owner member of the organization. # # @example # github = Github.new oauth_token: '...' # github.orgs.memberships.add 'org-name', 'member-name', role: 'role' # # @api public def create(*args) arguments(args, required: [:org_name, :username]) do assert_required :role end put_request("/orgs/#{arguments.org_name}/memberships/#{arguments.username}", arguments.params) end alias_method :update, :create alias_method :add, :create # Edit your organization membership # # @see https://developer.github.com/v3/orgs/members/#edit-your-organization-membership # @param [String] :org # @param [Hash] params # @option params [String] :state # Required. The state that the membership should be in. # Only "active" will be accepted. # # @example # github = Github.new oauth_token: '...' # github.orgs.memberships.edit 'org-name', state: 'active' # # @api public def edit(*args) arguments(args, required: [:org_name]) do assert_required :state end patch_request("/user/memberships/orgs/#{arguments.org_name}", arguments.params) end # Remove organization membership # # @see https://developer.github.com/v3/orgs/members/#remove-organization-membership # @param [String] :org # @param [String] :username # # @example # github = Github.new oauth_token: '...' # github.orgs.memberships.remove 'orgname', 'username' # # @api public def delete(*args) arguments(args, required: [:org_name, :username]) delete_request("/orgs/#{arguments.org_name}/memberships/#{arguments.username}", arguments.params) end alias_method :remove, :delete end # Client::Orgs::Memberships end # Github github_api-0.18.2/lib/github_api/client/orgs/members.rb0000644000004100000410000001131213214644262023037 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Orgs::Members < API # List members # # List all users who are members of an organization. A member is a user # that belongs to at least 1 team in the organization. # If the authenticated user is also a member of this organization then # both concealed and public members will be returned. # Otherwise only public members are returned. # # @see https://developer.github.com/v3/orgs/members/#members-list # # @param [Hash] params # @option params [String] :filter # Filter members returned in the list. Can be one of: # * 2fa_disabled: Members without two-factor authentication enabled. # Available for owners of organizations with private repositories. # * all: All members the authenticated user can see. # Default: all # @option params [String] :role # Filter members returned by their role. Can be one of: # * all: All members of the organization, regardless of role. # * admin: Organization owners. # * member: Non-owner organization members. # # @example # github = Github.new # github.orgs.members.list 'org-name' # github.orgs.members.list 'org-name' { |memb| ... } # # List public members # # @see https://developer.github.com/v3/orgs/members/#public-members-list # # Members of an organization can choose to have their # membership publicized or not. # # @example # github = Github.new # github.orgs.members.list 'org-name', public: true # github.orgs.members.list 'org-name', public: true { |memb| ... } # # @api public def list(*args) params = arguments(args, required: [:org_name]).params org_name = arguments.org_name response = if params.delete('public') get_request("/orgs/#{org_name}/public_members", params) else get_request("/orgs/#{org_name}/members", params) end return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Check if user is, publicly or privately, a member of an organization # # @example # github = Github.new # github.orgs.members.member? 'org-name', 'member-name' # # Check if a user is a public member of an organization # # @example # github = Github.new # github.orgs.members.member? 'org-name', 'member-name', public: true # # @api public def member?(*args) params = arguments(args, required: [:org_name, :user]).params org_name = arguments.org_name user = arguments.user response = if params.delete('public') get_request("/orgs/#{org_name}/public_members/#{user}", params) else get_request("/orgs/#{org_name}/members/#{user}", params) end response.status == 204 rescue Github::Error::NotFound false end # Remove a member # # Removing a user from this list will remove them from all teams and # they will no longer have any access to the organization's repositories. # # @see https://developer.github.com/v3/orgs/members/#remove-a-member # # @example # github = Github.new # github.orgs.members.remove 'org-name', 'member-name' # # @api public def delete(*args) arguments(args, required: [:org_name, :user]) delete_request("/orgs/#{arguments.org_name}/members/#{arguments.user}", arguments.params) end alias_method :remove, :delete # Publicize a user's membership # # @see https://developer.github.com/v3/orgs/members/#publicize-a-users-membership # # @example # github = Github.new oauth_token: '...' # github.orgs.members.publicize 'org-name', 'member-name' # # @api public def publicize(*args) arguments(args, required: [:org_name, :user]) put_request("/orgs/#{arguments.org_name}/public_members/#{arguments.user}", arguments.params) end alias_method :make_public, :publicize alias_method :publicize_membership, :publicize # Conceal a user's membership # # @see https://developer.github.com/v3/orgs/members/#conceal-a-users-membership # # @example # github = Github.new oauth_token: '...' # github.orgs.members.conceal 'org-name', 'member-name' # # @api public def conceal(*args) arguments(args, required: [:org_name, :user]) delete_request("/orgs/#{arguments.org_name}/public_members/#{arguments.user}", arguments.params) end alias_method :conceal_membership, :conceal end # Client::Orgs::Members end # Github github_api-0.18.2/lib/github_api/client/orgs/hooks.rb0000644000004100000410000001422213214644262022533 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # The Organizations Hooks API manages the post-receive web and # service hooks for an organization. class Client::Orgs::Hooks < API REQUIRED_PARAMS = %w( name config ).freeze # :nodoc: # List organization hooks # # @see https://developer.github.com/v3/orgs/hooks/#list-hooks # # @example # github = Github.new # github.orgs.hooks.list 'org-name' # github.orgs.hooks.list 'org-name' { |hook| ... } # # @api public def list(*args) arguments(args, required: [:org_name]) response = get_request("/orgs/#{arguments.org_name}/hooks", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get a single hook # # @see https://developer.github.com/v3/orgs/hooks/#get-single-hook # # @example # github = Github.new # github.orgs.hooks.get 'org-name', 'hook-id' # # @api public def get(*args) arguments(args, required: [:org_name, :id]) get_request("/orgs/#{arguments.org_name}/hooks/#{arguments.id}", arguments.params) end alias_method :find, :get # Create a hook # # @see https://developer.github.com/v3/orgs/hooks/#create-a-hook # # @param [Hash] params # @input params [String] :name # Required. The name of the service that is being called. # @input params [Hash] :config # Required. Key/value pairs to provide settings for this hook. # These settings vary between the services and are defined in # the github-services repository. Booleans are stored internally # as "1" for true, and "0" for false. Any JSON true/false values # will be converted automatically. # @input params [Array] :events # Determines what events the hook is triggered for. Default: ["push"] # @input params [Boolean] :active # Determines whether the hook is actually triggered on pushes. # # To create a webhook, the following fields are required by the config: # # @input config [String] :url # A required string defining the URL to which the payloads # will be delivered. # @input config [String] :content_type # An optional string defining the media type used to serialize # the payloads. Supported values include json and form. # The default is form. # @input config [String] :secret # An optional string that’s passed with the HTTP requests as # an X-Hub-Signature header. The value of this header is # computed as the HMAC hex digest of the body, # using the secret as the key. # @input config [String] :insecure_ssl # An optional string that determines whether the SSL certificate # of the host for url will be verified when delivering payloads. # Supported values include "0" (verification is performed) and # "1" (verification is not performed). The default is "0".or instance, if the library doesn't get updated to permit a given parameter the api call won't work, however if we skip permission all together, the endpoint should always work provided the actual resource path doesn't change. I'm in the process of completely removing the permit functionality. # # @example # github = Github.new # github.orgs.hooks.create 'org-name', # name: "web", # active: true, # config: { # url: "http://something.com/webhook" # } # } # # @api public def create(*args) arguments(args, required: [:org_name]) do assert_required REQUIRED_PARAMS end post_request("/orgs/#{arguments.org_name}/hooks", arguments.params) end # Edit a hook # # @see https://developer.github.com/v3/orgs/hooks/#edit-a-hook # # @param [Hash] params # @input params [Hash] :config # Required. Key/value pairs to provide settings for this hook. # These settings vary between the services and are defined in # the github-services repository. Booleans are stored internally # as "1" for true, and "0" for false. Any JSON true/false values # will be converted automatically. # @input params [Array] :events # Determines what events the hook is triggered for. Default: ["push"] # @input params [Array] :add_events # Determines a list of events to be added to the list of events # that the Hook triggers for. # @input params [Array] :remove_events # Determines a list of events to be removed from the list of # events that the Hook triggers for. # @input params [Boolean] :active # Determines whether the hook is actually triggered on pushes. # # @example # github = Github.new # github.orgs.hooks.edit 'org-name', 'hook-id', # "name" => "campfire", # "active" => true, # "config" => { # "subdomain" => "github", # "room" => "Commits", # "token" => "abc123" # } # # @api public def edit(*args) arguments(args, required: [:org_name, :id]) do assert_required REQUIRED_PARAMS end patch_request("/orgs/#{arguments.org_name}/hooks/#{arguments.id}", arguments.params) end # Ping a hook # # This will trigger a ping event to be sent to the hook. # # @see https://developer.github.com/v3/orgs/hooks/#ping-a-hook # # @example # github = Github.new # github.orgs.hooks.ping 'org-name', 'hook-id' # # @api public def ping(*args) arguments(args, required: [:org_name, :id]) post_request("/orgs/#{arguments.org_name}/hooks/#{arguments.id}/pings", arguments.params) end # Delete a hook # # @see https://developer.github.com/v3/orgs/hooks/#delete-a-hook # # @example # github = Github.new # github.orgs.hooks.delete 'org-name', 'hook-id' # # @api public def delete(*args) arguments(args, required: [:org_name, :id]) delete_request("/orgs/#{arguments.org_name}/hooks/#{arguments.id}", arguments.params) end end # Client::Orgs::Hooks end # Github github_api-0.18.2/lib/github_api/client/search/0000755000004100000410000000000013214644262021355 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/search/legacy.rb0000644000004100000410000000635713214644262023161 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Search::Legacy < API include Github::Utils::Url # Search issues # # Find issues by state and keyword. # # @param [Hash] params # @option params [String] :state # Indicates the state of the issues to return. Can be either open or closed. # @option params [String] :keyword # The search term # # @example # github = Github.new # github.search.legacy.issues 'owner', 'repo-name', 'open','api' # github.search.legacy.issues owner: 'owner', repo: 'repo-name', state: 'open', keyword: 'api' # # @api public def issues(*args) required = %w[ owner repo state keyword ] arguments(args, required: required) get_request("/legacy/issues/search/#{arguments.owner}/#{arguments.repo}/#{arguments.state}/#{escape_uri(arguments.keyword)}", arguments.params) end # Search repositories # # Find repositories by keyword. # # @param [Hash] params # @option params [String] :keyword # The search term # @option params [String] :language # Filter results by language # @option params [String] :start_page # The page number to fetch # @option params [String] :sort # The sort field. One of stars, forks, or updated. # Default: results are sorted by best match. # @option params [String] :order # The sort field. if sort param is provided. # Can be either asc or desc. # # @example # github = Github.new # github.search.legacy.repos 'api' # github.search.legacy.repos keyword: 'api' # # @api public def repos(*args) arguments(args, required: [:keyword]) get_request("/legacy/repos/search/#{escape_uri(arguments.keyword)}", arguments.params) end alias :repositories :repos # Search users # # Find users by keyword. # # @param [Hash] params # @option params [String] :keyword # The search term # @option params [String] :start_page # The page number to fetch # @option params [String] :sort # The sort field. One of stars, forks, or updated. # Default: results are sorted by best match. # @option params [String] :order # The sort field. if sort param is provided. # Can be either asc or desc. # # @example # github = Github.new # github.search.legacy.users 'user' # github.search.legacy.users keyword: 'user' # # @api public def users(*args) arguments(args, required: [:keyword]) get_request("/legacy/user/search/#{escape_uri(arguments.keyword)}", arguments.params) end # Search email # # This API call is added for compatibility reasons only. There’s no # guarantee that full email searches will always be available. # # @param [Hash] params # @option params [String] :email # The email address # # @example # github = Github.new # github.search.email 'email-address' # github.search.email email: 'email-address' # # @api public def email(*args) arguments(args, required: [:email]) get_request("/legacy/user/email/#{arguments.email}", arguments.params) end end # Search::Legacy end # Github github_api-0.18.2/lib/github_api/client/git_data/0000755000004100000410000000000013214644262021664 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/git_data/references.rb0000644000004100000410000001075413214644262024341 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::GitData::References < API VALID_REF_PARAM_NAMES = %w[ ref sha force ].freeze REQUIRED_REF_PARAMS = %w[ ref sha ].freeze VALID_REF_PARAM_VALUES = { 'ref' => %r{^refs\/\w+(\/\w+)*} # test fully qualified reference } # Get all references # # This will return an array of all the references on the system, # including things like notes and stashes if they exist on the server. # Anything in the namespace, not just heads and tags, # though that would be the most common. # # @example # github = Github.new # github.git_data.references.list 'user-name', 'repo-name' # # @example # github.git_data.references.list 'user-name', 'repo-name', ref:'tags' # # @api public def list(*args) arguments(args, required: [:user, :repo]) params = arguments.params user = arguments.user repo = arguments.repo response = if (ref = params.delete('ref')) validate_reference ref get_request("/repos/#{user}/#{repo}/git/refs/#{ref}", params) else get_request("/repos/#{user}/#{repo}/git/refs", params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a reference # # The ref in the URL must be formatted as heads/branch, # not just branch. For example, the call to get the data for a # branch named sc/featureA would be formatted as heads/sc/featureA # # @example # github = Github.new # github.git_data.references.get 'user-name', 'repo-name', 'heads/branch' # # @api public def get(*args) arguments(args, required: [:user, :repo, :ref]) validate_reference arguments.ref params = arguments.params get_request("/repos/#{arguments.user}/#{arguments.repo}/git/refs/#{arguments.ref}", params) end alias :find :get # Create a reference # # @param [Hash] params # @input params [String] :ref # The name of the fully qualified reference (ie: refs/heads/master). # If it doesn’t start with ‘refs’ and have at least two slashes, # it will be rejected. # @input params [String] :sha # The SHA1 value to set this reference to # # @example # github = Github.new # github.git_data.references.create 'user-name', 'repo-name', # ref: "refs/heads/master", # sha: "827efc6d56897b048c772eb4087f854f46256132" # # @api public def create(*args) arguments(args, required: [:user, :repo]) do permit VALID_REF_PARAM_NAMES assert_required REQUIRED_REF_PARAMS end params = arguments.params validate_reference params['ref'] post_request("/repos/#{arguments.user}/#{arguments.repo}/git/refs", params) end # Update a reference # # @param [Hash] params # @input params [String] :sha # The SHA1 value to set this reference to # @input params [Boolean] :force # Indicates whether to force the update or to make sure the update # is a fast-forward update. Leaving this out or setting it to false # will make sure you’re not overwriting work. Default: false # # @example # github = Github.new # github.git_data.references.update 'user-name', 'repo-name', 'heads/master', # sha: "827efc6d56897b048c772eb4087f854f46256132", # force: true # # @api public def update(*args) arguments(args, required: [:user, :repo, :ref]) do permit VALID_REF_PARAM_NAMES assert_required %w[ sha ] end patch_request("/repos/#{arguments.user}/#{arguments.repo}/git/refs/#{arguments.ref}", arguments.params) end # Delete a reference # # @example # github = Github.new # github.git_data.references.delete 'user-name', 'repo-name', # "heads/master" # # @api public def delete(*args) arguments(args, required: [:user, :repo, :ref]) params = arguments.params delete_request("/repos/#{arguments.user}/#{arguments.repo}/git/refs/#{arguments.ref}", params) end alias :remove :delete private def validate_reference(ref) refs = (ref =~ (/^(\/)?refs.*/) ? ref : "refs/#{ref}").gsub(/(\/)+/, '/') refs.gsub!(/^\//, '') unless VALID_REF_PARAM_VALUES['ref'] =~ refs raise ArgumentError, "Provided 'reference' is invalid" end end end # GitData::References end # Github github_api-0.18.2/lib/github_api/client/git_data/blobs.rb0000644000004100000410000000274513214644262023322 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # Since blobs can be any arbitrary binary data, the input and responses for # the blob api takes an encoding parameter that can be either utf-8 or base64. # If your data cannot be losslessly sent as a UTF-8 string, you can base64 encode it. class Client::GitData::Blobs < API VALID_BLOB_PARAM_NAMES = %w[ content encoding ].freeze # Get a blob # # @example # github = Github.new # github.git_data.blobs.get 'user-name', 'repo-name', 'sha' # # @api public def get(*args) arguments(args, required: [:user, :repo, :sha]) get_request("/repos/#{arguments.user}/#{arguments.repo}/git/blobs/#{arguments.sha}", arguments.params) end alias :find :get # Create a blob # # @param [Hash] params # @input params [String] :content # String of content. # @input params [String] :encoding # String containing encodingutf-8 or base64 # # @examples # github = Github.new # github.git_data.blobs.create 'user-name', 'repo-name', # content: "Content of the blob", # encoding: "utf-8" # # @api public def create(*args) arguments(args, required: [:user, :repo]) do permit VALID_BLOB_PARAM_NAMES assert_required VALID_BLOB_PARAM_NAMES end post_request("/repos/#{arguments.user}/#{arguments.repo}/git/blobs", arguments.params) end end # GitData::Blobs end # Github github_api-0.18.2/lib/github_api/client/git_data/commits.rb0000644000004100000410000000614313214644262023670 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::GitData::Commits < API VALID_COMMIT_PARAM_NAMES = %w[ message tree parents author committer name email date ].freeze REQUIRED_COMMIT_PARAMS = %w[ message tree parents ].freeze # Get a commit # # @example # github = Github.new # github.git_data.commits.get 'user-name', 'repo-name', 'sha' # # @example # commits = Github::Commits.new user: 'user-name', repo: 'repo-name' # commits.get sha: '...' # # @api public def get(*args) arguments(args, required: [:user, :repo, :sha]) params = arguments.params get_request("/repos/#{arguments.user}/#{arguments.repo}/git/commits/#{arguments.sha}", params) end alias :find :get # Create a commit # # @param [Hash] params # @input params [String] :message # The commit message # @input params [String] :tree # String of the SHA of the tree object this commit points to # @input params [Array[String]] :parents # Array of the SHAs of the commits that were the parents of this commit. # If omitted or empty, the commit will be written as a root commit. # For a single parent, an array of one SHA should be provided, # for a merge commit, an array of more than one should be provided. # # Optional Parameters # # You can provide an additional commiter parameter, which is a hash # containing information about the committer. Or, you can provide an author # parameter, which is a hash containing information about the author. # # The committer section is optional and will be filled with the author # data if omitted. If the author section is omitted, it will be filled # in with the authenticated users information and the current date. # # Both the author and commiter parameters have the same keys: # # @input params [String] :name # String of the name of the author (or commiter) of the commit # @input params [String] :email # String of the email of the author (or commiter) of the commit # @input params [Timestamp] :date # Indicates when this commit was authored (or committed). # This is a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ. # # @example # github = Github.new # github.git_data.commits.create 'user-name', 'repo-name', # message: "my commit message", # author: { # name: "Scott Chacon", # email: "schacon@gmail.com", # date: "2008-07-09T16:13:30+12:00" # }, # parents: [ # "7d1b31e74ee336d15cbd21741bc88a537ed063a0" # ], # tree: "827efc6d56897b048c772eb4087f854f46256132"] # # @api public def create(*args) arguments(args, required: [:user, :repo]) do permit VALID_COMMIT_PARAM_NAMES assert_required REQUIRED_COMMIT_PARAMS end post_request("/repos/#{arguments.user}/#{arguments.repo}/git/commits", arguments.params) end end # GitData::Commits end # Github github_api-0.18.2/lib/github_api/client/git_data/trees.rb0000644000004100000410000000645213214644262023342 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::GitData::Trees < API VALID_TREE_PARAM_NAMES = %w[ base_tree tree path mode type sha content url ].freeze VALID_TREE_PARAM_VALUES = { 'mode' => %w[ 100644 100755 040000 160000 120000 ], 'type' => %w[ blob tree commit ] } # Get a tree # # @example # github = Github.new # github.git_data.trees.get 'user-name', 'repo-name', 'sha' # github.git_data.trees.get 'user-name', 'repo-name', 'sha' do |file| # file.path # end # # Get a tree recursively # # @example # github = Github.new # github.git_data.trees.get 'user-name', 'repo-name', 'sha', recursive: true # # @api public def get(*args) arguments(args, required: [:user, :repo, :sha]) user = arguments.user repo = arguments.repo sha = arguments.sha params = arguments.params response = if params['recursive'] params['recursive'] = 1 get_request("/repos/#{user}/#{repo}/git/trees/#{sha}", params) else get_request("/repos/#{user}/#{repo}/git/trees/#{sha.to_s}", params) end return response unless block_given? response.tree.each { |el| yield el } end alias :find :get # Create a tree # # The tree creation API will take nested entries as well. # If both a tree and a nested path modifying that tree are specified, # it will overwrite the contents of that tree with the new path contents # and write a new tree out. # # @param [Hash] params # @input params [String] :base_tree # The SHA1 of the tree you want to update with new data # @input params [Array[Hash]] :tree # Required. Objects (of path, mode, type, and sha) # specifying a tree structure # # The tree parameter takes the following keys: # @input tree [String] :path # The file referenced in the tree # @input tree [String] :mode # The file mode; one of 100644 for file (blob), 100755 for # executable (blob), 040000 for subdirectory (tree), 160000 for # submodule (commit), or 120000 for a blob that specifies # the path of a symlink # @input tree [String] :type # Either blob, tree, or commit # @input tree [String] :sha # The SHA1 checksum ID of the object in the tree # @input tree [String] :content # The content you want this file to have - GitHub will write # this blob out and use the SHA for this entry. # Use either this or tree.sha # # @example # github = Github.new # github.git_data.trees.create 'user-name', 'repo-name', # tree: [ # { # path: "file.rb", # mode: "100644", # type: "blob", # sha: "44b4fc6d56897b048c772eb4087f854f46256132" # }, # ... # ] # # @api public def create(*args) arguments(args, required: [:user, :repo]) do assert_required %w[ tree ] permit VALID_TREE_PARAM_NAMES, 'tree', { recursive: true } assert_values VALID_TREE_PARAM_VALUES, 'tree' end post_request("/repos/#{arguments.user}/#{arguments.repo}/git/trees", arguments.params) end end # GitData::Trees end # Github github_api-0.18.2/lib/github_api/client/git_data/tags.rb0000644000004100000410000000545513214644262023160 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::GitData::Tags < API # This tags api only deals with tag objects - # so only annotated tags, not lightweight tags. # Refer https://developer.github.com/v3/git/tags/#parameters VALID_TAG_PARAM_NAMES = %w[ tag message object type name email date tagger ].freeze VALID_TAG_PARAM_VALUES = { 'type' => %w[ blob tree commit ] } # Get a tag # # @example # github = Github.new # github.git_data.tags.get 'user-name', 'repo-name', 'sha' # # @api public def get(*args) arguments(args, required: [:user, :repo, :sha]) params = arguments.params get_request("/repos/#{arguments.user}/#{arguments.repo}/git/tags/#{arguments.sha}", params) end alias :find :get # Create a tag object # # Note that creating a tag object does not create the reference that # makes a tag in Git. If you want to create an annotated tag in Git, # you have to do this call to create the tag object, and then create # the refs/tags/[tag] reference. If you want to create a lightweight # tag, you simply have to create the reference - # this call would be unnecessary. # # @param [Hash] params # @input params [String] :tag # The tag # @input params [String] :message # The tag message # @input params [String] :object # The SHA of the git object this is tagging # @input params [String] :type # The type of the object we're tagging. # Normally this is a commit but it can also be a tree or a blob # @input params [Hash] :tagger # A hash with information about the individual creating the tag. # # The tagger hash contains the following keys: # @input tagger [String] :name # The name of the author of the tag # @input tagger [String] :email # The email of the author of the tag # @input tagger [String] :date # When this object was tagged. This is a timestamp in ISO 8601 # format: YYYY-MM-DDTHH:MM:SSZ. # # @xample # github = Github.new # github.git_data.tags.create 'user-name', 'repo-name', # tag: "v0.0.1", # message: "initial version\n", # type: "commit", # object: "c3d0be41ecbe669545ee3e94d31ed9a4bc91ee3c", # tagger: { # name: "Scott Chacon", # email: "schacon@gmail.com", # date: "2011-06-17T14:53:3" # } # # @api public def create(*args) arguments(args, required: [:user, :repo]) do permit VALID_TAG_PARAM_NAMES assert_values VALID_TAG_PARAM_VALUES end post_request("/repos/#{arguments.user}/#{arguments.repo}/git/tags", arguments.params) end end # GitData::Tags end # Github github_api-0.18.2/lib/github_api/client/projects.rb0000644000004100000410000000360013214644262022265 0ustar www-datawww-data# encoding: utf-8 # frozen_string_literal: true require_relative '../api' module Github # Projects API class Client::Projects < API PREVIEW_MEDIA = "application/vnd.github.inertia-preview+json" # :nodoc: require_all 'github_api/client/projects', 'columns', 'cards' # Access to Projects::Columns API namespace :columns # Access to Projects::Cards API namespace :cards # Get properties for a single project # # @see https://developer.github.com/v3/projects/#get-a-project # # @example # github = Github.new # github.projects.get 1002604 # # @api public def get(*args) arguments(args, required: [:id]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA get_request("/projects/#{arguments.id}", params) end alias find get # Edit a project # # @param [Hash] params # @option params [String] :name # Optional string # @option params [String] :body # Optional string # @option params [String] :state # Optional string # # @example # github = Github.new # github.projects.edit 1002604, # name: "Outcomes Tracker", # body: "The board to track work for the Outcomes application." # # @api public def edit(*args) arguments(args, required: [:id]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA patch_request("/projects/#{arguments.id}", params) end # Delete a project # # @example # github = Github.new # github.projects.delete 1002604 # # @api public def delete(*args) arguments(args, required: [:id]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA delete_request("/projects/#{arguments.id}", arguments.params) end alias remove delete end # Projects end # Github github_api-0.18.2/lib/github_api/client/issues.rb0000644000004100000410000001652613214644262021762 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Issues < API require_all 'github_api/client/issues', 'assignees', 'comments', 'events', 'labels', 'milestones' VALID_ISSUE_PARAM_NAMES = %w[ assignee body creator direction filter labels milestone mentioned mime_type org resource since sort state title ].freeze VALID_ISSUE_PARAM_VALUES = { 'filter' => %w[ assigned created mentioned subscribed all ], 'state' => %w[ open closed all ], 'sort' => %w[ created updated comments ], 'direction' => %w[ desc asc ], 'since' => %r{\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z} } # Access to Issues::Assignees API namespace :assignees # Access to Issues::Comments API namespace :comments # Access to Issues::Events API namespace :events # Access to Issues::Comments API namespace :labels # Access to Issues::Comments API namespace :milestones # List your issues # # List all issues across all the authenticated user’s visible repositories # including owned repositories, member repositories, # and organization repositories. # # @example # github = Github.new oauth_token: '...' # github.issues.list # # List all issues across owned and member repositories for the # authenticated user. # # @example # github = Github.new oauth_token: '...' # github.issues.list :user # # List all issues for a given organization for the authenticated user. # # @example # github = Github.new oauth_token: '...' # github.issues.list org: 'org-name' # # List issues for a repository # # @example # github = Github.new # github.issues.list user: 'user-name', repo: 'repo-name' # # @param [Hash] params # @option params [String] :filter # * assigned Issues assigned to you (default) # * created Issues created by you # * mentioned Issues mentioning you # * subscribed Issues you've subscribed to updates for # * all All issues the user can see # @option params [String] :milestone # * Integer Milestone number # * none for Issues with no Milestone. # * * for Issues with any Milestone # @option params [String] :state # open, closed, default: open # @option params [String] :labels # String list of comma separated Label names. Example: bug,ui,@high # @option params [String] :assignee # * String User login # * none for Issues with no assigned User. # * * for Issues with any assigned User. # @option params [String] :creator # String User login # @option params [String] :mentioned # String User login # @option params [String] :sort # created, updated, comments, default: created # @option params [String] :direction # asc, desc, default: desc # @option params [String] :since # Optional string of a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ # # @example # github = Github.new oauth_token: '...' # github.issues.list since: '2011-04-12T12:12:12Z', # filter: 'created', # state: 'open', # labels: "bug,ui,bla", # sort: 'comments', # direction: 'asc' # # @api public def list(*args) params = arguments(args) do assert_values VALID_ISSUE_PARAM_VALUES end.params response = if (org = params.delete('org')) get_request("/orgs/#{org}/issues", params) elsif (user_name = params.delete('user')) && (repo_name = params.delete('repo')) list_repo user_name, repo_name elsif args.include? :user get_request("/user/issues", params) else get_request("/issues", params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # List issues for a repository # # def list_repo(user_name, repo_name, params) def list_repo(user, repo) get_request("/repos/#{user}/#{repo}/issues", arguments.params) end private :list_repo # Get a single issue # # @example # github = Github.new # github.issues.get 'user-name', 'repo-name', 'number' # def get(*args) arguments(args, required: [:user, :repo, :number]) get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}", arguments.params) end alias :find :get # Create an issue # # @param [Hash] params # @option params [String] :title # Required string # @option params [String] :body # Optional string # @option params [String] :assignee # Optional string - Login for the user that this issue should be # assigned to. Only users with push access can set the assignee for # new issues. The assignee is silently dropped otherwise. # @option params [Number] :milestone # Optional number - Milestone to associate this issue with. # Only users with push access can set the milestone for new issues. # The milestone is silently dropped otherwise. # @option params [Array[String]] :labels # Optional array of strings - Labels to associate with this issue # Only users with push access can set labels for new issues. # Labels are silently dropped otherwise. # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.issues.create # title: "Found a bug", # body: "I'm having a problem with this.", # assignee: "octocat", # milestone: 1, # labels: [ # "Label1", # "Label2" # ] # def create(*args) arguments(args, required: [:user, :repo]) do permit VALID_ISSUE_PARAM_NAMES assert_required %w[ title ] end post_request("/repos/#{arguments.user}/#{arguments.repo}/issues", arguments.params) end # Edit an issue # # @param [Hash] params # @option params [String] :title # Optional string # @option params [String] :body # Optional string # @option params [String] :assignee # Optional string - Login for the user that this issue should be assigned to. # @option params [String] :state # Optional string - State of the issue: open or closed # @option params [Number] :milestone # Optional number - Milestone to associate this issue with # @option params [Array[String]] :labels # Optional array of strings - Labels to associate with this issue. # Pass one or more Labels to replace the set of Labels on this Issue. # Send an empty array ([]) to clear all Labels from the Issue. # # @example # github = Github.new # github.issues.edit 'user-name', 'repo-name', 'number' # title: "Found a bug", # body: "I'm having a problem with this.", # assignee: "octocat", # milestone: 1, # labels": [ # "Label1", # "Label2" # ] # # @api public def edit(*args) arguments(args, required: [:user, :repo, :number]) do permit VALID_ISSUE_PARAM_NAMES end patch_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}", arguments.params) end end # Issues end # Github github_api-0.18.2/lib/github_api/client/markdown.rb0000644000004100000410000000402413214644262022257 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Markdown < API # Render an arbritrary Markdown document # # = Parameters # :text - Required string - The Markdown text to render # :mode - Optional string - The rendering mode # * markdown to render a document as plain Markdown, just # like README files are rendered. # * gfm to render a document as user-content, e.g. like user # comments or issues are rendered. In GFM mode, hard line breaks are # always taken into account, and issue and user mentions are # linked accordingly. # :context - Optional string - The repository context, only taken # into account when rendering as gfm # # = Examples # github = Github.new # github.markdown.render # "text": "Hello world github/linguist#1 **cool**, and #1!", # "mode": "gfm", # "context": "github/gollum" # def render(*args) arguments(args) do assert_required ['text'] end params = arguments.params params['raw'] = true post_request("markdown", arguments.params) end # Render a Markdown document in raw mode # # = Input # The raw API it not JSON-based. It takes a Markdown document as plaintext # text/plain or text/x-markdown and renders it as plain # Markdown without a repository context (just like a README.md file is # rendered – this is the simplest way to preview a readme online) # # = Examples # github = Github.new # github.markdown.render_raw "Hello github/linguist#1 **cool**, and #1!", # "accept": "text/plain", # def render_raw(*args) params = arguments(args).params params['data'] = args.shift params['raw'] = true params['accept'] = params.fetch('accept') { 'text/plain' } post_request("markdown/raw", params) end end # Markdown end # Github github_api-0.18.2/lib/github_api/client/activity/0000755000004100000410000000000013214644262021744 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/activity/watching.rb0000644000004100000410000001256713214644262024110 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # Watching a Repository registers the user to receive notificactions on new # discussions, as well as events in the user's activity feed. class Client::Activity::Watching < API # List repository watchers # # @see https://developer.github.com/v3/activity/watching/#list-watchers # # @example # github = Github.new # github.activity.watching.list user: 'user-name', repo: 'repo-name' # github.activity.watching.list user: 'user-naem', repo: 'repo-name' { |watcher| ... } # # @api public def list(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/subscribers", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # List repos being watched by a user # # @see https://developer.github.com/v3/activity/watching/#list-repositories-being-watched # # @example # github = Github.new # github.activity.watching.watched user: 'user-name' # # List repos being watched by the authenticated user # # @example # github = Github.new oauth_token: '...' # github.activity.watching.watched # # @api public def watched(*args) arguments(args) params = arguments.params response = if (user_name = params.delete('user')) get_request("/users/#{user_name}/subscriptions", params) else get_request('/user/subscriptions', params) end return response unless block_given? response.each { |el| yield el } end # Check if you are subscribed to a repository # # @see https://developer.github.com/v3/activity/watching/#get-a-repository-subscription # # @example # github = Github.new # github.activity.watching.subscribed? 'user-name', 'repo-name' # # @example # github.activity.watching.subscribed? user: 'user-name', repo: 'repo-name' # # @api public def subscribed?(*args) arguments(args, required: [:user, :repo]) get_request("/repos/#{arguments.user}/#{arguments.repo}/subscription", arguments.params) true rescue Github::Error::NotFound false end # Create subscription to a repository # # @see https://developer.github.com/v3/activity/watching/#set-a-repository-subscription # # @param [Hash] params # @option params [Boolean] :subscribed # Determines if notifications should be received from this repository. # @option params [Boolean] :ignored # Determines if all notifications should be blocked from this repository. # # @example # github = Github.new # github.activity.watching.create 'user-name', 'repo-name' # # @example # github.activity.watching.create user: 'user-name', repo: 'repo-name' # # @api public def create(*args) arguments(args, required: [:user, :repo]) put_request("/repos/#{arguments.user}/#{arguments.repo}/subscription", arguments.params) end alias_method :subscribe, :create # Delete a repository subscription # # @see https://developer.github.com/v3/activity/watching/#delete-a-repository-subscription # # @example # github = Github.new oauth_token: '...' # github.activity.watching.delete 'user-name', 'repo-name' # # @example # github.activity.watching.delete user: 'user-name', repo: 'repo-name' # # @api public def delete(*args) arguments(args, required: [:user, :repo]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/subscription", arguments.params) end alias_method :unsubscribe, :delete # Check if you are watching a repository # # @see https://developer.github.com/v3/activity/watching/#check-if-you-are-watching-a-repository-legacy # # @example # github = Github.new # github.activity.watching.watching? 'user-name', 'repo-name' # # @return [Boolean] # Returns true if this repo is watched by you, false otherwise. # # @api public def watching?(*args) arguments(args, required: [:user, :repo]) get_request("/user/subscriptions/#{arguments.user}/#{arguments.repo}", arguments.params) true rescue Github::Error::NotFound false end # Watch a repository # # You need to be authenticated to watch a repository # # @see https://developer.github.com/v3/activity/watching/#watch-a-repository-legacy # # @example # github = Github.new # github.activity.watching.watch 'user-name', 'repo-name' # # @api public def watch(*args) arguments(args, required: [:user, :repo]) put_request("/user/subscriptions/#{arguments.user}/#{arguments.repo}", arguments.params) end # Stop watching a repository # # You need to be authenticated to stop watching a repository. # # @see https://developer.github.com/v3/activity/watching/#stop-watching-a-repository-legacy # # @example # github = Github.new # github.activity.watching.unwatch 'user-name', 'repo-name' # # @api public def unwatch(*args) arguments(args, required: [:user, :repo]) delete_request("/user/subscriptions/#{arguments.user}/#{arguments.repo}", arguments.params) end end # Activity::Watching end # Github github_api-0.18.2/lib/github_api/client/activity/starring.rb0000644000004100000410000000763513214644262024135 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # Repository Starring is a feature that lets users bookmark repositories. # Stars are shown next to repositories to show an approximate level of interest. # Stars have no effect on notifications or the activity feed. class Client::Activity::Starring < API # List stargazers # # @see https://developer.github.com/v3/activity/starring/#list-stargazers # # @example # github = Github.new # github.activity.starring.list user: 'user-name', repo: 'repo-name' # github.activity.starring.list user: 'user-name', repo: 'repo-name' { |star| ... } # # @api public def list(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/stargazers", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # List repos being starred by a user # # @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred # # @param [Hash] params # @option params [String] :sort # One of created (when the repository was starred) or # updated (when it was last pushed to). # Default: created # @option params [String] :direction # One of asc (ascending) or desc (descending). # Default: desc # # @example # github = Github.new # github.activity.starring.starred user: 'user-name' # # List repos being starred by the authenticated user # # @example # github = Github.new oauth_token: '...' # github.activity.starring.starred # # @api public def starred(*args) arguments(args) params = arguments.params response = if (user_name = params.delete('user')) get_request("/users/#{user_name}/starred", params) else get_request('/user/starred', params) end return response unless block_given? response.each { |el| yield el } end # Check if you are starring a repository # # @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository # # @example # github = Github.new # github.activity.starring.starring? 'user-name', 'repo-name' # # @example # github.activity.starring.starring? user: 'user-name', repo: 'repo-name' # # @return [Boolean] # Returns true if this repo is starred by you, false otherwise. # # @api public def starring?(*args) arguments(args, required: [:user, :repo]) get_request("/user/starred/#{arguments.user}/#{arguments.repo}", arguments.params) true rescue Github::Error::NotFound false end # Star a repository # # You need to be authenticated to star a repository # # @see https://developer.github.com/v3/activity/starring/#star-a-repository # # @example # github = Github.new # github.activity.starring.star 'user-name', 'repo-name' # # @example # github.activity.starring.star user: 'user-name', repo: 'repo-name' # # @api public def star(*args) arguments(args, required: [:user, :repo]) put_request("/user/starred/#{arguments.user}/#{arguments.repo}", arguments.params) end # Unstar a repository # # You need to be authenticated to unstar a repository. # # @see https://developer.github.com/v3/activity/starring/#unstar-a-repository # # @example # github = Github.new # github.activity.starring.unstar 'user-name', 'repo-name' # # @example # github.activit.starring.unstar user: 'user-name', repo: 'repo-name' # # @api public def unstar(*args) arguments(args, required: [:user, :repo]) delete_request("/user/starred/#{arguments.user}/#{arguments.repo}", arguments.params) end end # Client::Activity::Starring end # Github github_api-0.18.2/lib/github_api/client/activity/notifications.rb0000644000004100000410000001367713214644262025160 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Activity::Notifications < API # List your notifications # # List all notifications for the current user, grouped by repository. # # @see https://developer.github.com/v3/activity/notifications/#list-your-notifications # # @param [Hash] params # @option params [Boolean] :all # If true, show notifications marked as read. # Default: false # @option params [Boolean] :participating # If true, only shows notifications in which the user # is directly participating or mentioned. Default: false # @option params [String] :since # Filters out any notifications updated before the given time. # This is a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ. # Default: Time.now # # @example # github = Github.new oauth_token: 'token' # github.activity.notifications.list # # List your notifications in a repository # # @see https://developer.github.com/v3/activity/notifications/#list-your-notifications-in-a-repository # # @example # github = Github.new # github.activity.notifications.list user: 'user-name', repo: 'repo-name' # # @api public def list(*args) arguments(args) params = arguments.params response = if ( (user_name = params.delete('user')) && (repo_name = params.delete('repo')) ) get_request("/repos/#{user_name}/#{repo_name}/notifications", params) else get_request('/notifications', params) end return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # View a single thread # # @see https://developer.github.com/v3/activity/notifications/#view-a-single-thread # # @example # github = Github.new oauth_token: 'token' # github.activity.notifications.get 'thread_id' # github.activity.notifications.get 'thread_id' { |thread| ... } # # @api public def get(*args) arguments(args, required: [:thread_id]) response = get_request("/notifications/threads/#{arguments.thread_id}", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :find, :get # Mark as read # # Marking a notification as “read” removes it from the default view on GitHub.com. # # @see https://developer.github.com/v3/activity/notifications/#mark-as-read # # @param [Hash] params # @option params [String] :last_read_at # Describes the last point that notifications were checked. # Anything updated since this time will not be updated. # This is a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ. # Default: Time.now # # @example # github = Github.new oauth_token: 'token' # github.activity.notifications.mark # # Mark notifications as read in a repository # # @see https://developer.github.com/v3/activity/notifications/#mark-notifications-as-read-in-a-repository # # @example # github.activity.notifications.mark user: 'user-name', repo: 'repo-name' # # Mark a thread as read # # @see https://developer.github.com/v3/activity/notifications/#mark-a-thread-as-read # # @example # github.activity.notifications.mark id: 'thread-id' # # @api public def mark(*args) arguments(args) params = arguments.params if ( (user_name = params.delete('user')) && (repo_name = params.delete('repo')) ) put_request("/repos/#{user_name}/#{repo_name}/notifications", params) elsif (thread_id = params.delete("id")) patch_request("/notifications/threads/#{thread_id}", params) else put_request('/notifications', params) end end # Check to see if the current user is subscribed to a thread. # # @see https://developer.github.com/v3/activity/notifications/#get-a-thread-subscription # # @example # github = Github.new oauth_token: 'token' # github.activity.notifications.subscribed? 'thread-id' # # @example # github.activity.notifications.subscribed? id: 'thread-id' # # @api public def subscribed?(*args) arguments(args, required: [:thread_id]) get_request("/notifications/threads/#{arguments.thread_id}/subscription", arguments.params) end # Create a thread subscription # # This lets you subscribe to a thread, or ignore it. Subscribing to a thread # is unnecessary if the user is already subscribed to the repository. Ignoring # a thread will mute all future notifications (until you comment or get # @mentioned). # # @see https://developer.github.com/v3/activity/notifications/#set-a-thread-subscription # # @param [Hash] params # @option params [Boolean] :subscribed # Determines if notifications should be received from this thread # @option params [Boolean] :ignored # Determines if all notifications should be blocked from this thread # # @example # github = Github.new oauth_token: 'token' # github.activity.notifications.create 'thread-id', # subscribed: true # ignored: false # # @api public def create(*args) arguments(args, required: [:thread_id]) put_request("/notifications/threads/#{arguments.thread_id}/subscription", arguments.params) end # Delete a thread subscription # # @see https://developer.github.com/v3/activity/notifications/#delete-a-thread-subscription # # @example # github = Github.new oauth_token: 'token' # github.activity.notifications.delete 'thread_id' # # @api public def delete(*args) arguments(args, required: [:thread_id]) delete_request("/notifications/threads/#{arguments.thread_id}/subscription", arguments.params) end alias_method :remove, :delete end # Client::Activity::Notifications end # Github github_api-0.18.2/lib/github_api/client/activity/feeds.rb0000644000004100000410000000227213214644262023362 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Activity::Feeds < API # List all the feeds available to the authenticated user. # # @see https://developer.github.com/v3/activity/feeds/#list-feeds # # @example # github = Github.new # github.activity.feeds.list # # @api public def list(*args) arguments(args) response = get_request("/feeds", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get all the items for a named timeline # # @see https://developer.github.com/v3/activity/feeds/#list-feeds # # @example # github = Github.new # github.activity.feeds.get "timeline" # # @param [String] name # the name of the timeline resource # # @api public def get(*args) arguments(args, required: [:name]) name = arguments.name response = list.body._links[name] if response params = arguments.params params['accept'] = response.type get_request(response.href, params) end end alias_method :find, :get end end # Github github_api-0.18.2/lib/github_api/client/activity/events.rb0000644000004100000410000002034013214644262023574 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Activity::Events < API # List all public events # # @see https://developer.github.com/v3/activity/events/#list-public-events # # @example # github = Github.new # github.activity.events.public # github.activity.events.public { |event| ... } # # @api public def public(*args) arguments(args) response = get_request("/events", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :public_events, :public alias_method :list_public, :public alias_method :list_public_events, :public # List all repository events for a given user # # @example # github = Github.new # github.activity.events.repository 'user-name', 'repo-name' # github.activity.events.repository 'user-name', 'repo-name' { |event| ... } # # @example # github.activity.events.repository user: 'user-name', repo: 'repo-name' # github.activity.events.repository user: 'user-name', repo: 'repo-name' {|event| ... } # # @api public def repository(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/events", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :repos, :repository alias_method :repo_events, :repository alias_method :repository_events, :repository alias_method :list_repository_events, :repository # List all issue events for a given repository # # @example # github = Github.new # github.activity.events.issue 'user-name', 'repo-name' # github.activity.events.issue 'user-name', 'repo-name' { |event| ... } # # @example # github.activity.events.issue user: 'user-name', repo: 'repo-name' # github.activity.events.issue user: 'user-name', repo: 'repo-name' { |event| ... } # # @api public def issue(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/events", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :issues, :issue alias_method :issue_events, :issue alias_method :list_issue_events, :issue # List all public events for a network of repositories # # @see https://developer.github.com/v3/activity/events/#list-public-events-for-a-network-of-repositories # # @example # github = Github.new # github.activity.events.network 'user-name', 'repo-name' # github.activity.events.network 'user-name', 'repo-name' { |event| ... } # # @example # github.activity.events.network user: 'user-name', repo: 'repo-name' # github.activity.events.network user: 'user-name', repo: 'repo-name' { |event| ... } # # @api public def network(*args) arguments(args, required: [:user, :repo]) response = get_request("/networks/#{arguments.user}/#{arguments.repo}/events", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :repo_network, :network alias_method :repository_network, :network alias_method :list_repo_network_events, :network alias_method :list_repository_network_events, :network # List all public events for an organization # # @see https://developer.github.com/v3/activity/events/#list-public-events-for-an-organization # # @example # github = Github.new # github.activity.events.org 'org-name' # github.activity.events.org 'org-name' { |event| ... } # # @example # github.activity.events.org name: 'org-name' # github.activity.events.org name: 'org-name' { |event| ... } # # @api public def org(*args) arguments(args, required: [:name]) response = get_request("/orgs/#{arguments.name}/events", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :organization, :org alias_method :list_orgs, :org alias_method :list_org_events, :org alias_method :list_organization_events, :org # List all events that a user has received # # @see https://developer.github.com/v3/activity/events/#list-events-that-a-user-has-received # # These are events that you’ve received by watching repos # and following users. If you are authenticated as the given user, # you will see private events. Otherwise, you’ll only see public events. # # @example # github = Github.new # github.activity.events.received 'user-name' # github.activity.events.received 'user-name' { |event| ... } # # List all public events that a user has received # # @see https://developer.github.com/v3/activity/events/#list-public-events-that-a-user-has-received # # @example # github = Github.new # github.activity.events.received 'user-name', public: true # github.activity.events.received 'user-name', public: true { |event| ... } # # @api public def received(*args) arguments(args, required: [:user]) params = arguments.params public_events = if params['public'] params.delete('public') '/public' end response = get_request("/users/#{arguments.user}/received_events#{public_events}", params) return response unless block_given? response.each { |el| yield el } end alias_method :user_received, :received alias_method :list_user_received, :received # List all events that a user has performed # # @see https://developer.github.com/v3/activity/events/#list-events-performed-by-a-user # # If you are authenticated as the given user, you will see your private # events. Otherwise, you’ll only see public events. # # @example # github = Github.new # github.activity.events.performed 'user-name' # github.activity.events.performed 'user-name' { |event| ... } # # List all public events that a user has performed # # @see https://developer.github.com/v3/activity/events/#list-public-events-performed-by-a-user # # @example # github = Github.new # github.activity.events.performed 'user-name', public: true # github.activity.events.performed 'user-name', public: true { |event| ... } # # @api public def performed(*args) arguments(args, required: [:user]) params = arguments.params public_events = if params['public'] params.delete('public') '/public' end response = get_request("/users/#{arguments.user}/events#{public_events}", params) return response unless block_given? response.each { |el| yield el } end alias_method :user_performed, :performed alias_method :list_user_performed, :performed # List all events for an organization # # @see https://developer.github.com/v3/activity/events/#list-events-for-an-organization # # This is the user's organization dashboard. You must be authenticated # as the user to view this. # # @example # github = Github.new # github.activity.events.user_org 'user-name', 'org-name' # github.activity.events.user_org 'user-name', 'org-name' { |event| ... } # # @example # github.activity.events.user_org user: 'user-name', name: 'org-name' # github.activity.events.user_org user: 'user-name', name: 'org-name' {|event| ...} # # @api public def user_org(*args) arguments(args, required: [:user, :name]) response = get_request("/users/#{arguments.user}/events/orgs/#{arguments.name}", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :user_organization, :user_org alias_method :list_user_org, :user_org alias_method :list_user_org_events, :user_org alias_method :list_user_organization_events, :user_org end # Client::Activity::Events end # Github github_api-0.18.2/lib/github_api/client/orgs.rb0000644000004100000410000000660713214644262021420 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github # Organizations API class Client::Orgs < API require_all 'github_api/client/orgs', 'hooks', 'members', 'memberships', 'projects', 'teams' # Access to Client::Orgs::Hooks API namespace :hooks # Access to Client::Orgs::Members API namespace :members # Access to Client::Orgs::Memberships API namespace :memberships # Access to Client::Orgs::Projects API namespace :projects # Access to Client::Orgs::Teams API namespace :teams # List all organizations # # Lists all organizations, in the order that they were created on GitHub. # # @see https://developer.github.com/v3/orgs/#list-all-organizations # # @param [Hash] params # @option params [String] :since # The integer ID of the last Organization that you've seen. # # @example # github = Github.new # github.orgs.list :every # # List all public organizations for a user. # # @see https://developer.github.com/v3/orgs/#list-user-organizations # # @example # github = Github.new # github.orgs.list user: 'user-name' # # List public and private organizations for the authenticated user. # # @example # github = Github.new oauth_token: '..' # github.orgs.list # # @api public def list(*args) params = arguments(args).params if (user_name = params.delete('user')) response = get_request("/users/#{user_name}/orgs", params) elsif args.map(&:to_s).include?('every') response = get_request('/organizations', params) else # For the authenticated user response = get_request('/user/orgs', params) end return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get properties for a single organization # # @see https://developer.github.com/v3/orgs/#get-an-organization # # @example # github = Github.new # github.orgs.get 'github' # # @api public def get(*args) arguments(args, required: [:org_name]) get_request("/orgs/#{arguments.org_name}", arguments.params) end alias_method :find, :get # Edit organization # # @see https://developer.github.com/v3/orgs/#edit-an-organization # # @param [Hash] params # @option params [String] :billing_email # Billing email address. This address is not publicized. # @option params [String] :company # The company name # @option params [String] :email # The publicly visible email address # @option params [String] :location # The location # @option params [String] :name # The shorthand name of the company. # @option params [String] :description # The description of the company. # # @example # github = Github.new oauth_token: '...' # github.orgs.edit 'github', # billing_email: "support@github.com", # blog: "https://github.com/blog", # company: "GitHub", # email: "support@github.com", # location: "San Francisco", # name: "github" # # @api public def edit(*args) arguments(args, required: [:org_name]) patch_request("/orgs/#{arguments.org_name}", arguments.params) end end # Orgs end # Github github_api-0.18.2/lib/github_api/client/repos/0000755000004100000410000000000013214644262021240 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/repos/contents.rb0000644000004100000410000002036013214644262023423 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # These API methods let you retrieve the contents of files within a repository # as Base64 encoded content. class Client::Repos::Contents < API REQUIRED_CONTENT_OPTIONS = %w[ path message content ] # Get the README # # This method returns the preferred README for a repository. # # @param [Hash] params # @option params [String] :ref # The name of the commit/branch/tag. # Default: the repository’s default branch (usually master) # # @example # github = Github.new # github.repos.contents.readme 'user-name', 'repo-name' # # @example # content = Github::Client::Repos::Contents.new user: 'user-name', repo: 'repo-name' # content.readme # # @api public def readme(*args) arguments(args, required: [:user, :repo]) get_request("/repos/#{arguments.user}/#{arguments.repo}/readme", arguments.params) end # Get contents # # This method returns the contents of any file or directory in a repository. # # @param [Hash] params # @option params [String] :path # The content path. # @option params [String] :ref # The name of the commit/branch/tag. # Default: the repository’s default branch (usually master) # # @example # github = Github.new # github.repos.contents.get 'user-name', 'repo-name', 'path' # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.repos.contents.get path: 'README.md' # # @api public def get(*args) arguments(args, required: [:user, :repo, :path]) get_request("/repos/#{arguments.user}/#{arguments.repo}/contents/#{arguments.path}", arguments.params) end alias :find :get # Create a file # # This method creates a new file in a repository # # @param [Hash] params # @option params [String] :path # Requried string. The content path # @option params [String] # @option params [String] :message # Requried string. The commit message. # @option params [String] :content # Requried string. The new file content, which will be Base64 encoded # @option params [String] :branch # The branch name. If not provided, uses the repository’s # default branch (usually master) # # Optional Parameters # # The :author section is optional and is filled in with the # :committer information if omitted. If the :committer # information is omitted, the authenticated user’s information is used. # # You must provide values for both :name and :email, whether # you choose to use :author or :committer. Otherwise, you’ll # receive a 500 status code. # # Both the author and commiter parameters have the same keys: # # @option params [String] :name # The name of the author (or commiter) of the commit # @option params [String] :email # The email of the author (or commiter) of the commit # # @example # github = Github.new # github.repos.contents.create 'user-name', 'repo-name', 'path', # path: 'hello.rb', # content: "puts 'hello ruby'", # message: "my commit message" # # @api public def create(*args) arguments(args, required: [:user, :repo, :path]) do assert_required REQUIRED_CONTENT_OPTIONS end params = arguments.params params.strict_encode64('content') put_request("/repos/#{arguments.user}/#{arguments.repo}/contents/#{arguments.path}", params) end # Update a file # # This method updates a file in a repository # # @param [Hash] params # @option params [String] :path # Requried string. The content path # @option params [String] # @option params [String] :message # Requried string. The commit message. # @option params [String] :content # Requried string. The new file content, which will be Base64 encoded # @option params [String] :sha # Required string. The blob SHA of the file being replaced. # @option params [String] :branch # The branch name. If not provided, uses the repository’s # default branch (usually master) # # Optional Parameters # # The :author section is optional and is filled in with the # :committer information if omitted. If the :committer # information is omitted, the authenticated user’s information is used. # # You must provide values for both :name and :email, whether # you choose to use :author or :committer. Otherwise, you’ll # receive a 500 status code. # # Both the author and commiter parameters have the same keys: # # @option params [String] :name # The name of the author (or commiter) of the commit # @option params [String] :email # The email of the author (or commiter) of the commit # # @example # github = Github.new # github.repos.contents.update 'user-name', 'repo-name', 'path', # path: 'hello.rb', # content: "puts 'hello ruby again'", # message: "my commit message", # sha: "25b0bef9e404bd2e3233de26b7ef8cbd86d0e913" # # @api public def update(*args) create(*args) end # Delete a file # # This method deletes a file in a repository # # @param [Hash] params # @option params [String] :path # Requried string. The content path # @option params [String] # @option params [String] :message # Requried string. The commit message. # @option params [String] :sha # Required string. The blob SHA of the file being replaced. # @option params [String] :branch # The branch name. If not provided, uses the repository’s # default branch (usually master) # # Optional Parameters # # The :author section is optional and is filled in with the # :committer information if omitted. If the :committer # information is omitted, the authenticated user’s information is used. # # You must provide values for both :name and :email, whether # you choose to use :author or :committer. Otherwise, you’ll # receive a 500 status code. # # Both the author and commiter parameters have the same keys: # # @option params [String] :name # The name of the author (or commiter) of the commit # @option params [String] :email # The email of the author (or commiter) of the commit # # @example # github = Github.new # github.repos.contents.delete 'user-name', 'repo-name', 'path', # path: 'hello.rb', # message: "delete hello.rb file", # sha: "329688480d39049927147c162b9d2deaf885005f" # def delete(*args) arguments(args, required: [:user, :repo, :path]) do assert_required %w[ path message sha ] end delete_request("/repos/#{arguments.user}/#{arguments.repo}/contents/#{arguments.path}", arguments.params) end # Get archive link # # This method will return a 302 to a URL to download a tarball or zipball # archive for a repository. Please make sure your HTTP framework is configured # to follow redirects or you will need to use the Location header to make # a second GET request. # # @note # For private repositories, these links are temporary and expire quickly. # # @param [Hash] params # @input params [String] :archive_format # Required string. Either tarball or zipball. Default: tarball # @input params [String] :ref # Optional string. A valid Git reference. # Default: the repository’s default branch (usually master) # # @example # github = Github.new # github.repos.contents.archive 'user-name', 'repo-name', # archive_format: "tarball", # ref: "master" # # @api public def archive(*args) arguments(args, required: [:user, :repo]) params = arguments.params archive_format = params.delete('archive_format') || 'tarball' ref = params.delete('ref') || 'master' disable_redirects do response = get_request("/repos/#{arguments.user}/#{arguments.repo}/#{archive_format}/#{ref}", params) response.headers.location end end end # Client::Repos::Contents end # Github github_api-0.18.2/lib/github_api/client/repos/pub_sub_hubbub.rb0000644000004100000410000001055213214644262024556 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Repos::PubSubHubbub < API HEADERS = { CONTENT_TYPE => 'application/x-www-form-urlencoded' } # Subscribe to existing topic/event through pubsubhubbub # # @param [Hash] params # @input params [String] :topic # Required string. The URI of the GitHub repository to subscribe to. # The path must be in the format of /:user/:repo/events/:event. # @input params [String] :callback # Required string - The URI to receive the updates to the topic. # # @example # github = Github.new oauth_token: 'token' # github.repos.pubsubhubbub.subscribe # 'https://github.com/:user/:repo/events/push', # 'github://Email?address=peter-murach@gmail.com', # verify: 'sync', # secret: '...' # # @api public def subscribe(*args) params = arguments(args, required: [:topic, :callback]).params _merge_action!("subscribe", arguments.topic, arguments.callback, params) params['headers'] = HEADERS post_request("/hub", params) end # Unsubscribe from existing topic/event through pubsubhubbub # # @param [Hash] params # @input params [String] :topic # Required string. The URI of the GitHub repository to # unsubscribe from. The path must be in the format of # /:user/:repo/events/:event. # @input params [String] :callback # Required string. The URI to unsubscribe the topic from. # # @example # github = Github.new oauth_token: 'token' # github.repos.pubsubhubbub.unsubscribe # 'https://github.com/:user/:repo/events/push', # 'github://Email?address=peter-murach@gmail.com', # verify: 'sync', # secret: '...' # # @api public def unsubscribe(*args) params = arguments(args, required: [:topic, :callback]).params _merge_action!("unsubscribe", arguments.topic, arguments.callback, params) params['headers'] = HEADERS post_request("/hub", params) end # Subscribe repository to service hook through pubsubhubbub # # @param [Hash] params # @input params [String] :event # Required hash key for the type of event. The default event is push. # # @example # github = Github.new oauth_token: '...' # github.repos.pubsubhubbub.subscribe_service 'user-name', 'repo-name', # 'campfire', # subdomain: 'github', # room: 'Commits', # token: 'abc123', # event: 'watch' # # @api public def subscribe_service(*args) params = arguments(args, required: [:user, :repo, :service]).params event = params.delete('event') || 'push' topic = "#{site}/#{arguments.user}/#{arguments.repo}/events/#{event}" callback = "github://#{arguments.service}?#{params.serialize}" subscribe(topic, callback) end alias :subscribe_repository :subscribe_service alias :subscribe_repo :subscribe_service # Subscribe repository to service hook through pubsubhubbub # # @param [Hash] params # @input params [String] :event # Optional hash key for the type of event. The default event is push. # # @example # github = Github.new oauth_token: '...' # github.repos.pubsubhubbub.unsubscribe_service 'user-name', 'repo-name', # 'campfire' # # @example # github.repos.pubsubhubbub.unsubscribe_service # user: 'user-name', # repo: 'repo-name', # service: 'service-name' # # @api public def unsubscribe_service(*args) params = arguments(args, required: [:user, :repo, :service]).params event = params.delete('event') || 'push' topic = "#{site}/#{arguments.user}/#{arguments.repo}/events/#{event}" callback = "github://#{arguments.service}" unsubscribe(topic, callback) end alias :unsubscribe_repository :unsubscribe_service alias :unsubscribe_repo :unsubscribe_service private def _merge_action!(action, topic, callback, params) # :nodoc: options = { "hub.mode" => action.to_s, "hub.topic" => topic.to_s, "hub.callback" => callback, "hub.verify" => params.delete('verify') || 'sync', "hub.secret" => params.delete('secret') || '' } params.merge! options end end # Client::Repos::PubSubHubbub end # Github github_api-0.18.2/lib/github_api/client/repos/releases.rb0000644000004100000410000001403113214644262023367 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # The Releases API class Client::Repos::Releases < API require_all 'github_api/client/repos/releases', 'assets', 'tags' # Access to Repos::Releases::Assets API namespace :assets # Access to Repos::Releases::Tags API namespace :tags # List releases for a repository # # Users with push access to the repository will receive all releases # (i.e., published releases and draft releases). Users with pull access # will receive published releases only. # # @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository # # @example # github = Github.new # github.repos.releases.list 'owner', 'repo' # github.repos.releases.list 'owner', 'repo' { |release| ... } # # @api public def list(*args) arguments(args, required: [:owner, :repo]) response = get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get a single release # # @see https://developer.github.com/v3/repos/releases/#get-a-single-release # # @example # github = Github.new # github.repos.releases.get 'owner', 'repo', 'id' # # @api public def get(*args) arguments(args, required: [:owner, :repo, :id]).params get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}" , arguments.params) end alias_method :find, :get # Create a release # # Users with push access to the repository can create a release. # # @see https://developer.github.com/v3/repos/releases/#create-a-release # # @param [Hash] params # @input params [String] :tag_name # Required. The name of the tag. # @input params [String] :target_commitish # Specifies the commitish value that determines where the Git tag # is created from. Can be any branch or commit SHA. Defaults to # the repository's default branch (usually 'master'). # Unused if the Git tag already exists. # @input params [String] :name # The name of the release. # @input params [String] :body # Text describing the contents of the tag. # @input params [Boolean] :draft # true to create a draft (unpublished) release, # false to create a published one. Default: false # @input params [Boolean] :prerelease # true to identify the release as a prerelease. # false to identify the release as a full release. Default: false # # @example # github = Github.new # github.repos.releases.create 'owner', 'repo', # tag_name: "v1.0.0", # target_commitish: "master", # name: "v1.0.0", # body: "Description of the release", # draft: false, # prerelease: false # # @api public def create(*args) arguments(args, required: [:owner, :repo]) do assert_required :tag_name end post_request("/repos/#{arguments.owner}/#{arguments.repo}/releases", arguments.params) end # Edit a release # # Users with push access to the repository can edit a release. # # @see https://developer.github.com/v3/repos/releases/#edit-a-release # # @param [String] :owner # @param [String] :repo # @param [Integer] :id # @param [Hash] params # @input params [String] :tag_name # Required. The name of the tag. # @input params [String] :target_commitish # Specifies the commitish value that determines where the Git tag # is created from. Can be any branch or commit SHA. Defaults to # the repository's default branch (usually 'master'). # Unused if the Git tag already exists. # @input params [String] :name # The name of the release. # @input params [String] :body # Text describing the contents of the tag. # @input params [Boolean] :draft # true to create a draft (unpublished) release, # false to create a published one. Default: false # @input params [Boolean] :prerelease # true to identify the release as a prerelease. # false to identify the release as a full release. Default: false # # @example # github = Github.new # github.repos.releases.edit 'owner', 'repo', 'id', # tag_name: "v1.0.0", # target_commitish: "master", # name: "v1.0.0", # body: "Description of the release", # draft: false, # prerelease: false # # @api public def edit(*args) arguments(args, required: [:owner, :repo, :id]) patch_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}", arguments.params) end alias_method :update, :edit # Delete a release # # Users with push access to the repository can delete a release. # # @see https://developer.github.com/v3/repos/releases/#delete-a-release # # @param [String] :owner # @param [String] :repo # @param [Integer] :id # # @example # github = Github.new # github.repos.releases.delete 'owner', 'repo', 'id' # # @api public def delete(*args) arguments(args, required: [:owner, :repo, :id]).params delete_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}", arguments.params) end # Get the latest release # # View the latest published full release for the repository. # Draft releases and prereleases are not returned. # # @see https://developer.github.com/v3/repos/releases/#get-the-latest-release # # @param [String] :owner # @param [String] :repo # # @example # github = Github.new # github.repos.releases.latest 'owner', 'repo' # # @api public def latest(*args) arguments(args, required: [:owner, :repo]).params get_request("repos/#{arguments.owner}/#{arguments.repo}/releases/latest", arguments.params) end end # Client::Repos::Statuses end # Github github_api-0.18.2/lib/github_api/client/repos/deployments.rb0000644000004100000410000001076613214644262024142 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Repos::Deployments < API VALID_DEPLOYMENTS_OPTIONS = %w[ ref auto_merge required_contexts payload environment description ] VALID_STATUS_OPTIONS = %w[ state target_url description ] PREVIEW_MEDIA = 'application/vnd.github.cannonball-preview+json'.freeze # :nodoc: # List deployments on a repository # # @xample # github = Github.new # github.repos.deployments.list 'user-name', 'repo-name' # github.repos.deployments.list 'user-name', 'repo-name' { |deployment| ... } # # @api public def list(*args) arguments(args, required: [:user, :repo]) params = arguments.params params['accept'] ||= PREVIEW_MEDIA response = get_request("repos/#{arguments.user}/#{arguments.repo}/deployments", params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Create a deployment # # @param [Hash] params # @option params [String] :ref # Required string. The ref to deploy. This can be a branch, tag, or sha. # @option params [Boolean] :auto_merge # Optional boolean. Merge the default branch into the requested. # @option params [Array] :required_contexts # Optional array of status contexts verified against commit status checks. # If this parameter is omitted from the parameters then all unique # contexts will be verified before a deployment is created. To bypass # checking entirely pass an empty array. Defaults to all unique contexts. # @option params [String] :payload # Optional JSON payload with extra information about the deployment. # Default: "" # @option params [String] :payload # Optional String. Name for the target deployment environment (e.g., # production, staging, qa). Default: "production" # @option params [String] :description # Optional string. Optional short description. # # @example # github = Github.new # github.repos.deployments.create 'user-name', 'repo-name', ref: '...' # github.repos.deployments.create # 'user-name', # 'repo-name', # ref: '...', # description: 'New deploy', # force: true # # @api public def create(*args) arguments(args, required: [:user, :repo]) do permit VALID_DEPLOYMENTS_OPTIONS assert_required %w[ ref ] end params = arguments.params params['accept'] ||= PREVIEW_MEDIA post_request("repos/#{arguments.user}/#{arguments.repo}/deployments", arguments.params) end # List the statuses of a deployment. # # @param [Hash] params # @option params [String] :id # Required string. Id of the deployment being queried. # # @example # github = Github.new # github.repos.deployments.statuses 'user-name', 'repo-name', DEPLOYMENT_ID # github.repos.deployments.statuses 'user-name', 'repo-name', DEPLOYMENT_ID { |status| ... } # # @api public def statuses(*args) arguments(args, required: [:user, :repo, :id]) params = arguments.params params['accept'] ||= PREVIEW_MEDIA statuses = get_request("repos/#{arguments.user}/#{arguments.repo}/deployments/#{arguments.id}/statuses", params) return statuses unless block_given? statuses.each { |status| yield status } end # Create a deployment status # # @param [Hash] params # @option params [String] :id # Required string. Id of the deployment being referenced. # @option params [String] :state # Required string. State of the deployment. Can be one of: # pending, success, error, or failure. # @option params [String] :target_url # Optional string. The URL associated with the status. # @option params [String] :description # Optional string. A short description of the status. # # @example # github = Github.new # github.repos.deployments.create_status 'user-name', 'repo-name', DEPLOYMENT_ID, state: '...' # # @api public def create_status(*args) arguments(args, required: [:user, :repo, :id]) do assert_required %w[ state ] permit VALID_STATUS_OPTIONS end params = arguments.params params['accept'] ||= PREVIEW_MEDIA post_request("repos/#{arguments.user}/#{arguments.repo}/deployments/#{arguments.id}/statuses", params) end end # Client::Repos::Deployments end # Github github_api-0.18.2/lib/github_api/client/repos/statuses.rb0000644000004100000410000000600313214644262023437 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # The Status API allows external services to mark commits with a success, # failure, error, or pending state, which is then reflected in pull requests # involving those commits. class Client::Repos::Statuses < API VALID_STATUS_PARAM_NAMES = %w[ state target_url description context ].freeze # :nodoc: REQUIRED_PARAMS = %w[ state ].freeze # :nodoc: # List Statuses for a specific SHA # # @param [String] :ref # Ref to fetch the status for. It can be a SHA, a branch name, # or a tag name. # # @example # github = Github.new # github.repos.statuses.list 'user-name', 'repo-name', 'ref' # github.repos.statuses.list 'user-name', 'repo-name', 'ref' { |status| ... } # # Get the combined Status for a specific Ref # # @example # github = Github.new # github.repos.statuses.list 'user', 'repo', 'ref', combined: true # # @api public def list(*args) arguments(args, required: [:user, :repo, :ref]) params = arguments.params user, repo, ref = arguments.user, arguments.repo, arguments.ref response = if params.delete('combined') get_request("/repos/#{user}/#{repo}/commits/#{ref}/status", params) else get_request("/repos/#{user}/#{repo}/commits/#{ref}/statuses", params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # Create a status # # @param [Hash] params # @input params [String] :state # Required. The state of the status. Can be one of pending, # success, error, or failure. # @input params [String] :target_url # The target URL to associate with this status. This URL will # be linked from the GitHub UI to allow users to easily see # the ‘source’ of the Status. # # For example, if your Continuous Integration system is posting # build status, you would want to provide the deep link for # the build output for this specific SHA: # http://ci.example.com/user/repo/build/sha. # @input params [String] :description # A short description of the status # @input params [String] :context # A string label to differentiate this status from the # status of other systems. Default: "default" # # @example # github = Github.new # github.repos.statuses.create 'user-name', 'repo-name', 'sha', # state: "success", # target_url: "http://ci.example.com/johndoe/my-repo/builds/sha", # description: "Successful build #3 from origin/master" # # @api public def create(*args) arguments(args, required: [:user, :repo, :sha]) do permit VALID_STATUS_PARAM_NAMES, recursive: false assert_required REQUIRED_PARAMS end post_request("/repos/#{arguments.user}/#{arguments.repo}/statuses/#{arguments.sha}", arguments.params) end end # Client::Repos::Statuses end # Github github_api-0.18.2/lib/github_api/client/repos/pages.rb0000644000004100000410000000272313214644262022670 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # The Pages API retrieves information about your GitHub Pages configuration, # and the statuses of your builds. Information about the site and the builds # can only be accessed by authenticated owners, even though the websites # are public. class Client::Repos::Pages < API # List Pages builds # # @example # github = Github.new # github.repos.pages.list owner: 'owner-name', repo: 'repo-name' # # github = Github.new # github.repos.pages.list :latest, owner: 'owner-name', repo: 'repo-name' # @api public def list(*args) arguments(args, required: [:owner, :repo]) response = if args.map(&:to_s).include?('latest') get_request("/repos/#{arguments.owner}/#{arguments.repo}/pages/builds/latest", arguments.params) else get_request("/repos/#{arguments.owner}/#{arguments.repo}/pages/builds", arguments.params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # Get information about a Pages site # # @example # github = Github.new # github.repos.pages.get owner: 'owner-name', repo: 'repo-name' # # @api public def get(*args) arguments(args, required: [:owner, :repo]) get_request("/repos/#{arguments.owner}/#{arguments.repo}/pages", arguments.params) end alias :find :get end # Client::Repos::Pages end # Github github_api-0.18.2/lib/github_api/client/repos/merging.rb0000644000004100000410000000265013214644262023220 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # The Repo Merging API supports merging branches in a repository. This # accomplishes essentially the same thing as merging one branch into another # in a local repository and then pushing to GitHub. class Client::Repos::Merging < API VALID_MERGE_PARAM_NAMES = %w[ base head commit_message ].freeze # :nodoc: REQUIRED_MERGE_PARAMS = %w[ base head ].freeze # :nodoc: # Perform a merge # # @param [Hash] params # @input params [String] :base # Required. The name of the base branch that the head will be merged into. # @input params [String] :head # Required. The head to merge. This can be a branch name or a commit SHA1. # @input params [String] :commit_message # Commit message to use for the merge commit. # If omitted, a default message will be used. # # @example # github = Github.new # github.repos.merging.merge 'user', 'repo', # base: "master", # head: "cool_feature", # commit_message: "Shipped cool_feature!" # # @api public def merge(*args) arguments(args, required: [:user, :repo]) do permit VALID_MERGE_PARAM_NAMES assert_required REQUIRED_MERGE_PARAMS end post_request("/repos/#{arguments.user}/#{arguments.repo}/merges", arguments.params) end end # Client::Repos::Merging end # Github github_api-0.18.2/lib/github_api/client/repos/comments.rb0000644000004100000410000000665413214644262023425 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Repos::Comments < API REQUIRED_COMMENT_OPTIONS = %w[ body ].freeze VALID_COMMENT_OPTIONS = %w[ body line path position ].freeze # List commit comments for a repository # # @example # github = Github.new # github.repos.comments.list 'user-name', 'repo-name' # # @example # github.repos.comments.list 'user-name', 'repo-name' { |com| ... } # # List comments for a single commit # # @example # github.repos.comments.list 'user-name', 'repo-name', # sha: '6dcb09b5b57875f334f61aebed695e2e4193db5e' # # @api public def list(*args) arguments(args, required: [:user, :repo]) params = arguments.params user = arguments.user repo = arguments.repo response = if (sha = params.delete('sha')) get_request("/repos/#{user}/#{repo}/commits/#{sha}/comments", params) else get_request("/repos/#{user}/#{repo}/comments", params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # Gets a single commit comment # # @example # github = Github.new # github.repos.comments.get 'user-name', 'repo-name', 'id' # # @api public def get(*args) arguments(args, required: [:user, :repo, :id]) get_request("/repos/#{arguments.user}/#{arguments.repo}/comments/#{arguments.id}", arguments.params) end alias :find :get # Creates a commit comment # # @param [Hash] params # @option params [String] :body # Required. The contents of the comment. # @option params [String] :path # Required. Relative path of the file to comment on. # @option params [Number] :position # Required number - Line index in the diff to comment on. # @option params [Number] :line # Required number - Line number in the file to comment on. # # @example # github = Github.new # github.repos.comments.create 'user-name', 'repo-name', 'sha-key', # body: "Nice change", # position: 4, # line: 1, # path: "file1.txt" # # @api public def create(*args) arguments(args, required: [:user, :repo, :sha]) do assert_required REQUIRED_COMMENT_OPTIONS end post_request("/repos/#{arguments.user}/#{arguments.repo}/commits/#{arguments.sha}/comments", arguments.params) end # Update a commit comment # # @param [Hash] params # @option params [String] :body # Required. The contents of the comment. # # @example # github = Github.new # github.repos.comments.update 'user-name', 'repo-name', 'id', # body: "Nice change" # # @api public def update(*args) arguments(args, required: [:user, :repo, :id]) do assert_required REQUIRED_COMMENT_OPTIONS end patch_request("/repos/#{arguments.user}/#{arguments.repo}/comments/#{arguments.id}", arguments.params) end # Deletes a commit comment # # @example # github = Github.new # github.repos.comments.delete 'user-name', 'repo-name', 'id' # # @api public def delete(*args) arguments(args, required: [:user, :repo, :id]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/comments/#{arguments.id}", arguments.params) end end # Client::Repos::Comments end # Github github_api-0.18.2/lib/github_api/client/repos/commits.rb0000644000004100000410000000471113214644262023243 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Repos::Commits < API VALID_COMMITS_OPTIONS = %w[ sha path author since until ].freeze # List commits on a repository # # @param [Hash] params # @option params [String] :sha # Sha or branch to start listing commits from. # @option params [String] :path # Only commits containing this file path will be returned. # @option params [String] :author # GitHub login, name or email by which to filter by commit author. # @option params [String] :since # Only commits after this date will be returned. This is a timestamp # in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ. # @option params [String] :until # Only commits before this date will be returned. This is a timestamp # in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ. # # @example # github = Github.new # github.repos.commits.list 'user-name', 'repo-name', sha: '...' # github.repos.commits.list 'user-name', 'repo-name', sha: '...' { |commit| ... } # # @api public def list(*args) arguments(args, required: [:user, :repo]) do permit VALID_COMMITS_OPTIONS end response = get_request("/repos/#{arguments.user}/#{arguments.repo}/commits", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Gets a single commit # # @example # github = Github.new # github.repos.commits.get 'user-name', 'repo-name', '6dcb09b5b57875f334f61aebed6' # # @api public def get(*args) arguments(args, required: [:user, :repo, :sha]) get_request("/repos/#{arguments.user}/#{arguments.repo}/commits/#{arguments.sha}", arguments.params) end alias :find :get # Compares two commits # # @note Both :base and :head can be either branch names in :repo or # branch names in other repositories in the same network as :repo. # For the latter case, use the format user:branch: # # @example # github = Github.new # github.repos.commits.compare 'user-name', 'repo-name', 'v0.4.8', 'master' # # @api public def compare(*args) arguments(args, required: [:user, :repo, :base, :head]) get_request("/repos/#{arguments.user}/#{arguments.repo}/compare/#{arguments.base}...#{arguments.head}", arguments.params) end end # Client::Repos::Commits end # Github github_api-0.18.2/lib/github_api/client/repos/projects.rb0000644000004100000410000000345413214644262023424 0ustar www-datawww-data# frozen_string_literal: true require_relative '../../api' module Github class Client::Repos::Projects < API PREVIEW_MEDIA = "application/vnd.github.inertia-preview+json".freeze # :nodoc: # List a repo's projects # # @example # github = Github.new # github.repos.projects.list owner: 'owner-name', repo: 'repo-name' # # @example # github = Github.new # github.repos.projects.list state: 'open', owner: 'owner-name', repo: 'repo-name' # # @example # github.repos.projects.list owner: 'owner-name', repo: 'repo-name' { |cbr| .. } # # @return [Array] # # @api public def list(*args) arguments(args, required: [:owner, :repo]) params = arguments.params params["accept"] ||= PREVIEW_MEDIA response = get_request("/repos/#{arguments.owner}/#{arguments.repo}/projects", params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Create a new project for the specified repo # # @param [Hash] params # @option params [String] :name # Required string - The name of the project. # @option params [String] :body # Optional string - The body of the project. # # @example # github = Github.new # github.repos.projects.create 'owner-name', 'repo-name', name: 'project-name' # github.repos.projects.create name: 'project-name', body: 'project-body', owner: 'owner-name', repo: 'repo-name' # # @api public def create(*args) arguments(args, required: [:owner, :repo]) do assert_required %w[ name ] end params = arguments.params params["accept"] ||= PREVIEW_MEDIA post_request("/repos/#{arguments.owner}/#{arguments.repo}/projects", params) end end # Projects end # Github github_api-0.18.2/lib/github_api/client/repos/releases/0000755000004100000410000000000013214644262023043 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/repos/releases/assets.rb0000644000004100000410000000760013214644262024675 0ustar www-datawww-data# encoding: utf-8 require_relative '../../../api' module Github # The Release Assets API class Client::Repos::Releases::Assets < API VALID_ASSET_PARAM_NAMES = %w[ name label content_type ].freeze # :nodoc: # List assets for a release # # @example # github = Github.new # github.repos.releases.assets.list 'owner', 'repo', 'id' # github.repos.releases.assets.list 'owner', 'repo', 'id' { |asset| ... } # # @api public def list(*args) arguments(args, required: [:owner, :repo, :id]).params response = get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}/assets", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single release asset # # @example # github = Github.new # github.repos.releases.assets.get 'owner', 'repo', 'id' # # @api public def get(*args) arguments(args, required: [:owner, :repo, :id]).params get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/assets/#{arguments.id}" , arguments.params) end alias :find :get # Upload a release asset # # @param [Hash] params # @input params [String] :name # Required string. The file name of the asset # @input params [String] :content_type # Required string. The content type of the asset. # Example: “application/zip”. # # @example # github = Github.new # github.repos.releases.assets.upload 'owner', 'repo', 'id', 'file-path' # name: "batman.jpg", # content_type: "application/octet-stream" # # @api public def upload(*args) arguments(args, required: [:owner, :repo, :id, :filepath]) do permit VALID_ASSET_PARAM_NAMES end params = arguments.params unless type = params['content_type'] type = infer_media(arguments.filepath) end file = Faraday::UploadIO.new(arguments.filepath, type) options = { headers: { content_type: type }, endpoint: upload_endpoint, query: {'name' => params['name']} } params['data'] = file.read params['options'] = options post_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}/assets", params) ensure file.close if file end # Infer media type of the asset # def infer_media(filepath) require 'mime/types' types = MIME::Types.type_for(filepath) types.empty? ? 'application/octet-stream' : types.first rescue LoadError raise Github::Error::UnknownMedia.new(filepath) end # Edit a release asset # # Users with push access to the repository can edit a release asset. # # @param [Hash] params # @input params [String] :name # Required. The file name of the asset. # @input params [String] :label # An alternate short description of the asset. # Used in place of the filename. # # @example # github = Github.new # github.repos.releases.assets.edit 'owner', 'repo', 'id', # name: "foo-1.0.0-osx.zip", # label: "Mac binary" # # @api public def edit(*args) arguments(args, required: [:owner, :repo, :id]) do permit VALID_ASSET_PARAM_NAMES end patch_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/assets/#{arguments.id}", arguments.params) end alias :update :edit # Delete a release asset # # @example # github = Github.new # github.repos.releases.assets.delete 'owner', 'repo', 'id' # # @api public def delete(*args) arguments(args, required: [:owner, :repo, :id]) delete_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/assets/#{arguments.id}", arguments.params) end end # Client::Repos::Releases::Assets end # Github github_api-0.18.2/lib/github_api/client/repos/releases/tags.rb0000644000004100000410000000127013214644262024326 0ustar www-datawww-data# encoding: utf-8 require_relative '../../../api' module Github # The Releases API class Client::Repos::Releases::Tags < API # Get a published release with the specified tag. # # @see https://developer.github.com/v3/repos/releases/#get-a-release-by-tag-name # # @example # github = Github.new # github.repos.releases.tags.get 'owner', 'repo', 'tag' # # @api public def get(*args) arguments(args, required: [:owner, :repo, :tag]).params get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/tags/#{arguments.tag}" , arguments.params) end alias_method :find, :get end # Client::Repos::Releases::Tags end # Github github_api-0.18.2/lib/github_api/client/repos/statistics.rb0000644000004100000410000000574413214644262023771 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # The Repository Statistics API allows you to fetch the data that GitHub uses # for visualizing different types of repository activity. class Client::Repos::Statistics < API # Get contributors list with additions, deletions, and commit counts # # @example # github = Github.new # github.repos.stats.contributors user: '...', repo: '...' # github.repos.stats.contributors user: '...', repo: '...' { |stat| ... } # # @api public def contributors(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/contributors", arguments.params) return response unless block_given? response.each { |el| yield el } end # Get the last year of commit activity data # # Returns the last year of commit activity grouped by week. # The days array is a group of commits per day, starting on Sunday # # @example # github = Github.new # github.repos.stats.commit_activity user: '...', repo: '...' # github.repos.stats.commit_activity user: '...', repo: '...' { |stat| ... } # # @api public def commit_activity(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/commit_activity", arguments.params) return response unless block_given? response.each { |el| yield el } end # Get the number of additions and deletions per week # # @example # github = Github.new # github.repos.stats.code_frequency user: '...', repo: '...' # github.repos.stats.code_frequency user: '...', repo: '...' { |stat| ... } # # @api public def code_frequency(*args) arguments(args, required: [:user, :repo]) get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/code_frequency", arguments.params) end # Get the weekly commit count for the repo owner and everyone else # # @example # github = Github.new # github.repos.stats.participation user: '...', repo: '...' # github.repos.stats.participation user: '...', repo: '...' { |stat| ... } # # @api public def participation(*args) arguments(args, required: [:user, :repo]) get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/participation", arguments.params) end # Get the number of commits per hour in each day # # @example # github = Github.new # github.repos.stats.punch_card user: '...', repo: '...' # github.repos.stats.punch_card user: '...', repo: '...' { |stat| ... } # # @api public def punch_card(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/punch_card", arguments.params) return response unless block_given? response.each { |el| yield el } end end # Client::Repos::Statistics end # Github github_api-0.18.2/lib/github_api/client/repos/forks.rb0000644000004100000410000000252013214644262022710 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Repos::Forks < API # List repository forks # # @param [Hash] params # @input params [String] :sort # The sort order. Can be either newest, oldest, or stargazers. # Default: newest # # @example # github = Github.new # github.repos.forks.list 'user-name', 'repo-name' # github.repos.forks.list 'user-name', 'repo-name' { |fork| ... } # # @api public def list(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/forks", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Create a fork for the authenticated user # # @param [Hash] params # @input params [String] :organization # The organization login. The repository will be forked into # this organization. # # @example # github = Github.new # github.repos.forks.create 'user-name', 'repo-name', # organization: "github" # # @api public def create(*args) arguments(args, required: [:user, :repo]) post_request("/repos/#{arguments.user}/#{arguments.repo}/forks", arguments.params) end end # Client::Repos::Forks end # Github github_api-0.18.2/lib/github_api/client/repos/branches/0000755000004100000410000000000013214644262023025 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/repos/branches/protections.rb0000644000004100000410000000434613214644262025732 0ustar www-datawww-data# encoding: utf-8 require_relative '../../../api' module Github # The Branch Protections API class Client::Repos::Branches::Protections < API VALID_PROTECTION_PARAM_NAMES = %w[ required_status_checks required_pull_request_reviews enforce_admins restrictions accept ].freeze # Get a single branch's protection # # @example # github = Github.new # github.repos.branches.protections.get 'user', 'repo', 'branch' # # @api public def get(*args) arguments(args, required: [:user, :repo, :branch]) get_request("/repos/#{arguments.user}/#{arguments.repo}/branches/#{arguments.branch}/protection", arguments.params) end alias :find :get # Edit a branch protection # # Users with push access to the repository can edit a branch protection. # # @param [Hash] params # @input params [String] :required_status_checks # Required. # @input params [String] :enforce_admins # Required. # @input params [String] :restrictions # Required. # @input params [String] :required_pull_request_reviews # Required. # Look to the branch protection API t see how to use these # https://developer.github.com/v3/repos/branches/#update-branch-protection # # @example # github = Github.new # github.repos.branches.protections.edit 'user', 'repo', 'branch', # required_pull_request_reviews: {dismiss_stale_reviews: false} # # @api public def edit(*args) arguments(args, required: [:user, :repo, :branch]) do permit VALID_PROTECTION_PARAM_NAMES end put_request("/repos/#{arguments.user}/#{arguments.repo}/branches/#{arguments.branch}/protection", arguments.params) end alias :update :edit # Delete a branch protection # # @example # github = Github.new # github.repos.branches.protections.delete 'user', 'repo', 'branch' # # @api public def delete(*args) arguments(args, required: [:user, :repo, :branch]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/branches/#{arguments.branch}/protection", arguments.params) end alias :remove :delete end # Client::Repos::Branches::Protections end # Github github_api-0.18.2/lib/github_api/client/repos/downloads.rb0000644000004100000410000000313313214644262023557 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Repos::Downloads < API REQUIRED_PARAMS = %w[ name size ].freeze VALID_DOWNLOAD_PARAM_NAMES = %w[ name size description content_type ].freeze # List downloads for a repository # # @example # github = Github.new # github.repos.downloads.list 'user-name', 'repo-name' # github.repos.downloads.list 'user-name', 'repo-name' { |downl| ... } # # @api public def list(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/downloads", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single download # # @example # github = Github.new # github.repos.downloads.get 'user-name', 'repo-name', 'download-id' # # @api public def get(*args) arguments(args, required: [:user, :repo, :id]) get_request("/repos/#{arguments.user}/#{arguments.repo}/downloads/#{arguments.id}", arguments.params) end alias :find :get # Delete download from a repository # # @example # github = Github.new # github.repos.downloads.delete 'user-name', 'repo-name', 'download-id' # # @api public def delete(*args) arguments(args, required: [:user, :repo, :id]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/downloads/#{arguments.id}", arguments.params) end alias :remove :delete end # Repos::Downloads end # Github github_api-0.18.2/lib/github_api/client/repos/keys.rb0000644000004100000410000000546213214644262022547 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Repos::Keys < API # List deploy keys # # @see https://developer.github.com/v3/repos/keys/#list # # @param [String] :user # @param [String :repo # # @example # github = Github.new # github.repos.keys.list 'user-name', 'repo-name' # github.repos.keys.list 'user-name', 'repo-name' { |key| ... } # # @example # keys = Github::Repos::Keys.new user: 'user-name', repo: 'repo-name' # keys.list # # @api public def list(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/keys", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get a key # # @see https://developer.github.com/v3/repos/keys/#get # # @param [String] :user # @param [String] :repo # @param [Integer] :id # # @example # github = Github.new # github.repos.keys.get 'user-name', 'repo-name', 'key-id' # # @api public def get(*args) arguments(args, required: [:user, :repo, :id]) get_request("/repos/#{arguments.user}/#{arguments.repo}/keys/#{arguments.id}", arguments.params) end alias_method :find, :get # Create a key # # @see https://developer.github.com/v3/repos/keys/#create # # @param [String] :user # @param [String] :repo # @param [Hash] params # @option params [String] :title # Required string. # @option params [String] :key # Required string. # @option params [String] :read_only # If true, the key will only be able to read repository contents. # Otherwise, the key will be able to read and write. # # @example # github = Github.new # github.repos.keys.create 'user-name', 'repo-name', # title: "octocat@octomac", # key: "ssh-rsa AAA..." # # @api public def create(*args) arguments(args, required: [:user, :repo]) post_request("/repos/#{arguments.user}/#{arguments.repo}/keys", arguments.params) end alias_method :add, :create # Delete key # # @see https://developer.github.com/v3/repos/keys/#delete # # @param [String] :user # @param [String] :repo # @param [Integer] :id # # @example # github = Github.new # github.repos.keys.delete 'user-name', 'repo-name', 'key-id' # # @api public def delete(*args) arguments(args, required: [:user, :repo, :id]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/keys/#{arguments.id}", arguments.params) end alias_method :remove, :delete end # Client::Repos::Keys end # Github github_api-0.18.2/lib/github_api/client/repos/branches.rb0000644000004100000410000000267513214644262023364 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Repos::Branches < API require_all 'github_api/client/repos/branches', 'protections' # Access to Repos::Branches::Protections API namespace :protections # List branches # # @example # github = Github.new # github.repos.branches.list 'user-name', 'repo-name' # github.repos(user: 'user-name', repo: 'repo-name').branches.list # # @example # repos = Github::Repos.new # repos.branches.list 'user-name', 'repo-name' # # @api public def list(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/branches", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Get branch # # @example # github = Github.new # github.repos.branches.get 'user-name', 'repo-name', 'branch-name' # github.repos.branches.get user: 'user-name', repo: 'repo-name', branch: 'branch-name' # github.repos(user: 'user-name', repo: 'repo-name', branch: 'branch-name').branches.get # @api public def get(*args) arguments(args, required: [:user, :repo, :branch]) get_request("/repos/#{arguments.user}/#{arguments.repo}/branches/#{arguments.branch}", arguments.params) end alias :find :get end # Client::Repos::Branches end # Github github_api-0.18.2/lib/github_api/client/repos/collaborators.rb0000644000004100000410000000474013214644262024440 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Repos::Collaborators < API # List collaborators # # When authenticating as an organization owner of an # organization-owned repository, all organization owners are included # in the list of collaborators. Otherwise, only users with access to the # repository are returned in the collaborators list. # # @example # github = Github.new # github.repos.collaborators.list 'user-name', 'repo-name' # # @example # github.repos.collaborators.list 'user-name', 'repo-name' { |cbr| .. } # # @return [Array] # # @api public def list(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/collaborators", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Add collaborator # # @example # github = Github.new # github.repos.collaborators.add 'user', 'repo', 'username' # # @example # collaborators = Github::Repos::Collaborators.new # collaborators.add 'user', 'repo', 'username' # # @api public def add(*args) arguments(args, required: [:user, :repo, :username]) put_request("/repos/#{arguments.user}/#{arguments.repo}/collaborators/#{arguments.username}", arguments.params) end alias :<< :add # Checks if user is a collaborator for a given repository # # @example # github = Github.new # github.repos.collaborators.collaborator?('user', 'repo', 'username') # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.collaborators.collaborator? username: 'collaborator' # # @api public def collaborator?(*args) arguments(args, required: [:user, :repo, :username]) get_request("/repos/#{arguments.user}/#{arguments.repo}/collaborators/#{arguments.username}", arguments.params) true rescue Github::Error::NotFound false end # Removes collaborator # # @example # github = Github.new # github.repos.collaborators.remove 'user', 'repo', 'username' # # @api public def remove(*args) arguments(args, required: [:user, :repo, :username]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/collaborators/#{arguments.username}", arguments.params) end end # Client::Repos::Collaborators end # Github github_api-0.18.2/lib/github_api/client/repos/hooks.rb0000644000004100000410000001546713214644262022725 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github # The Repository Hooks API manages the post-receive web and # service hooks for a repository. class Client::Repos::Hooks < API VALID_HOOK_PARAM_NAMES = %w[ name config active events add_events remove_events ].freeze # :nodoc: # Active hooks can be configured to trigger for one or more events. # The default event is push. The available events are: VALID_HOOK_PARAM_VALUES = { 'events' => %w[ push issues issue_comment commit_comment pull_request gollum watch download fork fork_apply member public ] }.freeze # :nodoc: REQUIRED_PARAMS = %w[ name config ].freeze # :nodoc: # List repository hooks # # @example # github = Github.new # github.repos.hooks.list 'user-name', 'repo-name' # github.repos.hooks.list 'user-name', 'repo-name' { |hook| ... } # # @api public def list(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/hooks", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single hook # # @example # github = Github.new # github.repos.hooks.get 'user-name', 'repo-name', 'hook-id' # # @api public def get(*args) arguments(args, required: [:user, :repo, :id]) get_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}", arguments.params) end alias :find :get # Create a hook # # @param [Hash] params # @input params [String] :name # Required. The name of the service that is being called. # @input params [Hash] :config # Required. Key/value pairs to provide settings for this hook. # These settings vary between the services and are defined in # the github-services repository. Booleans are stored internally # as “1” for true, and “0” for false. Any JSON true/false values # will be converted automatically. # @input params [Array] :events # Determines what events the hook is triggered for. Default: ["push"] # @input params [Boolean] :active # Determines whether the hook is actually triggered on pushes. # # To create a webhook, the following fields are required by the config: # # @input config [String] :url # A required string defining the URL to which the payloads # will be delivered. # @input config [String] :content_type # An optional string defining the media type used to serialize # the payloads. Supported values include json and form. # The default is form. # @input config [String] :secret # An optional string that’s passed with the HTTP requests as # an X-Hub-Signature header. The value of this header is # computed as the HMAC hex digest of the body, # using the secret as the key. # @input config [String] :insecure_ssl # An optional string that determines whether the SSL certificate # of the host for url will be verified when delivering payloads. # Supported values include "0" (verification is performed) and # "1" (verification is not performed). The default is "0". # # @example # github = Github.new # github.repos.hooks.create 'user-name', 'repo-name', # name: "web", # active: true, # config: { # url: "http://something.com/webhook" # } # } # # @api public def create(*args) arguments(args, required: [:user, :repo]) do permit VALID_HOOK_PARAM_NAMES, recursive: false assert_required REQUIRED_PARAMS end post_request("/repos/#{arguments.user}/#{arguments.repo}/hooks", arguments.params) end # Edit a hook # # @param [Hash] params # @input params [Hash] :config # Required. Key/value pairs to provide settings for this hook. # These settings vary between the services and are defined in # the github-services repository. Booleans are stored internally # as “1” for true, and “0” for false. Any JSON true/false values # will be converted automatically. # @input params [Array] :events # Determines what events the hook is triggered for. Default: ["push"] # @input params [Array] :add_events # Determines a list of events to be added to the list of events # that the Hook triggers for. # @input params [Array] :remove_events # Determines a list of events to be removed from the list of # events that the Hook triggers for. # @input params [Boolean] :active # Determines whether the hook is actually triggered on pushes. # # @example # github = Github.new # github.repos.hooks.edit 'user-name', 'repo-name', 'hook-id', # "name" => "campfire", # "active" => true, # "config" => { # "subdomain" => "github", # "room" => "Commits", # "token" => "abc123" # } # # @api public def edit(*args) arguments(args, required: [:user, :repo, :id]) do permit VALID_HOOK_PARAM_NAMES, recursive: false assert_required REQUIRED_PARAMS end patch_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}", arguments.params) end # Test a hook # # This will trigger the hook with the latest push to the current # repository if the hook is subscribed to push events. If the hook # is not subscribed to push events, the server will respond with 204 # but no test POST will be generated. # # @example # github = Github.new # github.repos.hooks.test 'user-name', 'repo-name', 'hook-id' # # @api public def test(*args) arguments(args, required: [:user, :repo, :id]) post_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}/tests", arguments.params) end # Ping a hook # # This will trigger a ping event to be sent to the hook. # # @example # github = Github.new # github.repos.hooks.ping 'user-name', 'repo-name', 'hook-id' # # @api public def ping(*args) arguments(args, required: [:user, :repo, :id]) post_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}/pings", arguments.params) end # Delete a hook # # @example # github = Github.new # github.repos.hooks.delete 'user-name', 'repo-name', 'hook-id' # # @api public def delete(*args) arguments(args, required: [:user, :repo, :id]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}", arguments.params) end end # Client::Repos::Hooks end # Github github_api-0.18.2/lib/github_api/client/scopes.rb0000644000004100000410000000223013214644262021726 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Scopes < API # Check what OAuth scopes you have. # # @see https://developer.github.com/v3/oauth/#scopes # # @example # github = Github.new oauth_token: 'e72e16c7e42f292c6912e7710c838347ae17' # github.scopes.all # # @example # github = Github.new # github.scopes.list 'e72e16c7e42f292c6912e7710c838347ae17' # # @example # github = Github.new # github.scopes.list token: 'e72e16c7e42f292c6912e7710c838347ae17' # # @api public def list(*args) arguments(args) params = arguments.params token = args.shift if token.is_a?(Hash) && !params['token'].nil? token = params.delete('token') elsif token.nil? token = oauth_token end if token.nil? raise ArgumentError, 'Access token required' end headers = { 'Authorization' => "token #{token}" } params['headers'] = headers response = get_request("/user", params) response.headers.oauth_scopes.split(',').map(&:strip) end alias all list end # Client::Scopes end # Github github_api-0.18.2/lib/github_api/client/gists.rb0000644000004100000410000001620013214644262021565 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Gists < API require_all 'github_api/client/gists', 'comments' # Access to Gists::Comments API namespace :comments # List a user's gists # # @see https://developer.github.com/v3/gists/#list-a-users-gists # # @example # github = Github.new # github.gists.list user: 'user-name' # # List the authenticated user’s gists or if called anonymously, # this will returns all public gists # # @example # github = Github.new oauth_token: '...' # github.gists.list # # List all public gists # # @see https://developer.github.com/v3/gists/#list-all-public-gists # # github = Github.new # github.gists.list :public # # @return [Hash] # # @api public def list(*args) params = arguments(args).params response = if (user = params.delete('user')) get_request("/users/#{user}/gists", params) elsif args.map(&:to_s).include?('public') get_request("/gists/public", params) else get_request("/gists", params) end return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # List the authenticated user's starred gists # # @see https://developer.github.com/v3/gists/#list-starred-gists # # @example # github = Github.new oauth_token: '...' # github.gists.starred # # @return [Hash] # # @api public def starred(*args) arguments(args) response = get_request("/gists/starred", arguments.params) return response unless block_given? response.each { |el| yield el } end # Get a single gist # # @see https://developer.github.com/v3/gists/#get-a-single-gist # # @example # github = Github.new # github.gists.get 'gist-id' # # Get a specific revision of gist # # @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist # # @example # github = Github.new # github.gists.get 'gist-id', sha: ' # # @return [Hash] # # @api public def get(*args) arguments(args, required: [:id]) if (sha = arguments.params.delete('sha')) get_request("/gists/#{arguments.id}/#{sha}") else get_request("/gists/#{arguments.id}", arguments.params) end end alias_method :find, :get # Create a gist # # @see https://developer.github.com/v3/gists/#create-a-gist # # @param [Hash] params # @option params [String] :description # Optional string # @option params [Boolean] :public # Required boolean # @option params [Hash] :files # Required hash - Files that make up this gist. # The key of which should be a required string filename and # the value another required hash with parameters: # @option files [String] :content # Required string - File contents. # # @example # github = Github.new # github.gists.create # description: 'the description for this gist', # public: true, # files: { # 'file1.txt' => { # content: 'String file contents' # } # } # # @return [Hash] # # @api public def create(*args) arguments(args) post_request("/gists", arguments.params) end # Edit a gist # # @see https://developer.github.com/v3/gists/#edit-a-gist # # @param [Hash] params # @option [String] :description # Optional string # @option [Hash] :files # Optional hash - Files that make up this gist. # The key of which should be a optional string filename and # the value another optional hash with parameters: # @option [String] :content # Updated string - Update file contents. # @option [String] :filename # Optional string - New name for this file. # # @xample # github = Github.new oauth_token: '...' # github.gists.edit 'gist-id', # description: 'the description for this gist', # files: { # 'file1.txt' => { # content: 'Updated file contents' # }, # 'old_name.txt' => { # filename: 'new_name.txt', # content: 'modified contents' # }, # 'new_file.txt' => { # content: 'a new file contents' # }, # 'delete_the_file.txt' => nil # } # # @return [Hash] # # @api public def edit(*args) arguments(args, required: [:id]) patch_request("/gists/#{arguments.id}", arguments.params) end # List gist commits # # @see https://developer.github.com/v3/gists/#list-gist-commits # # @example # github = Github.new # github.gists.commits 'gist-id' # # @api public def commits(*args) arguments(args, required: [:id]) response = get_request("/gists/#{arguments.id}/commits") return response unless block_given? response.each { |el| yield el } end # Star a gist # # @see https://developer.github.com/v3/gists/#star-a-gist # # @example # github = Github.new # github.gists.star 'gist-id' # # @api public def star(*args) arguments(args, required: [:id]) put_request("/gists/#{arguments.id}/star", arguments.params) end # Unstar a gist # # @see https://developer.github.com/v3/gists/#unstar-a-gist # # @xample # github = Github.new # github.gists.unstar 'gist-id' # # @api public def unstar(*args) arguments(args, required: [:id]) delete_request("/gists/#{arguments.id}/star", arguments.params) end # Check if a gist is starred # # @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred # # @example # github = Github.new # github.gists.starred? 'gist-id' # # @api public def starred?(*args) arguments(args, required: [:id]) get_request("/gists/#{arguments.id}/star", arguments.params) true rescue Github::Error::NotFound false end # Fork a gist # # @example # github = Github.new # github.gists.fork 'gist-id' # # @api public def fork(*args) arguments(args, required: [:id]) post_request("/gists/#{arguments.id}/forks", arguments.params) end # List gist forks # # @see https://developer.github.com/v3/gists/#list-gist-forks # # @example # github = Github.new # github.gists.forks 'gist-id' # # @api public def forks(*args) arguments(args, required: [:id]) response = get_request("/gists/#{arguments.id}/forks") return response unless block_given? response.each { |el| yield el } end # Delete a gist # # @see https://developer.github.com/v3/gists/#delete-a-gist # # @example # github = Github.new # github.gists.delete 'gist-id' # # @api public def delete(*args) arguments(args, required: [:id]) delete_request("/gists/#{arguments.id}", arguments.params) end end # Gists end # Github github_api-0.18.2/lib/github_api/client/emojis.rb0000644000004100000410000000050313214644262021721 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Emojis < API # Lists all the emojis. # # @example # Github.emojis.list # # @api public def list(*args) arguments(args) get_request("/emojis", arguments.params) end end # Client::Emojis end # Github github_api-0.18.2/lib/github_api/client/projects/0000755000004100000410000000000013214644262021741 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/projects/columns.rb0000644000004100000410000000775513214644262023764 0ustar www-datawww-data# frozen_string_literal: true # encoding: utf-8 require_relative '../../api' module Github class Client::Projects::Columns < API REQUIRED_COLUMN_PARAMS = %w(name).freeze REQUIRED_MOVE_COLUMN_PARAMS = %w(position).freeze # List a project's columns # # @example # github = Github.new # github.projects.columns.list :project_id # # @see https://developer.github.com/v3/projects/columns/#list-project-columns # # @api public def list(*args) arguments(args, required: [:project_id]) params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA response = get_request("/projects/#{arguments.project_id}/columns", params) return response unless block_given? response.each { |el| yield el } end alias all list # Get a project columns # # @example # github = Github.new # github.projects.columns.get :column_id # # @see https://developer.github.com/v3/projects/columns/#get-a-project-column # # @api public def get(*args) arguments(args, required: [:column_id]) params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA get_request("/projects/columns/#{arguments.column_id}", params) end alias find get # Create a project column # # @param [Hash] params # @option params [String] :name # Required. The name of the column. # # @example # github = Github.new # github.projects.columns.create :project_id, name: 'column-name' # # @see https://developer.github.com/v3/projects/columns/#create-a-project-column # # @api public def create(*args) arguments(args, required: [:project_id]) do assert_required REQUIRED_COLUMN_PARAMS end params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA post_request("/projects/#{arguments.project_id}/columns", params) end # Update a project column # # @param [Hash] params # @option params [String] :name # Required. The name of the column. # # @example # github = Github.new # github.repos.projects.update :column_id, name: 'new-column-name' # # @see https://developer.github.com/v3/projects/columns/#update-a-project-column # # @api public def update(*args) arguments(args, required: [:column_id]) do assert_required REQUIRED_COLUMN_PARAMS end params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA patch_request("/projects/columns/#{arguments.column_id}", params) end alias edit update # Delete a project column # # @example # github = Github.new # github.projects.columns.delete :column_id # # @see https://developer.github.com/v3/projects/columns/#delete-a-project-column # # @api public def delete(*args) arguments(args, required: [:column_id]) params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA delete_request("/projects/columns/#{arguments.column_id}", params) end alias remove delete # Move a project column # # @param [Hash] params # @option params [String] :position # Required. Required. Can be one of 'first', 'last', or # 'after:', where is the id value of a column in # the same project. # # @example # github = Github.new # github.projects.columns.move :column_id, position: 'first' # # @see https://developer.github.com/v3/projects/columns/#move-a-project-column # # @api public def move(*args) arguments(args, required: [:column_id]) do assert_required REQUIRED_MOVE_COLUMN_PARAMS end params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA post_request("/projects/columns/#{arguments.column_id}/moves", params) end end end github_api-0.18.2/lib/github_api/client/projects/cards.rb0000644000004100000410000001112113214644262023356 0ustar www-datawww-data# frozen_string_literal: true # encoding: utf-8 require_relative '../../api' module Github class Client::Projects::Cards < API REQUIRED_MOVE_CARD_PARAMS = %w(position).freeze # List project cards for a column # # @example # github = Github.new # github.projects.cards.list :column_id # # @see https://developer.github.com/v3/projects/cards/#list-project-cards # # @api public def list(*args) arguments(args, required: [:column_id]) params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA response = get_request("/projects/columns/#{arguments.column_id}/cards", params) return response unless block_given? response.each { |el| yield el } end alias all list # Get a project card # # @example # github = Github.new # github.projects.cards.get :card_id # # @see https://developer.github.com/v3/projects/cards/#get-a-project-card # # @api public def get(*args) arguments(args, required: [:card_id]) params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA get_request("/projects/columns/cards/#{arguments.card_id}", params) end alias find get # Create a project card for a column # # @param [Hash] params # @option params [String] :note # The card's note content. Only valid for cards without another type of # content, so this must be omitted if content_id and content_type are # specified. # @option params [Integer] :content_id # The id of the Issue to associate with this card. # @option params [String] :content_type # The type of content to associate with this card. Can only be "Issue" at # this time. # # @example # github = Github.new # github.projects.cards.create :column_id, note: 'Card Note' # # @example # github = Github.new # github.projects.cards.create :column_id, content_id: , content_type: 'content-type' # # @see https://developer.github.com/v3/projects/cards/#create-a-project-card # # @api public def create(*args) arguments(args, required: [:column_id]) params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA post_request("/projects/columns/#{arguments.column_id}/cards", params) end # Update a project card # # @param [Hash] params # @option params [String] :note # The card's note content. Only valid for cards without another type of # content, so this cannot be specified if the card already has a # content_id and content_type. # # @example # github = Github.new # github.projects.cards.update :card_id, note: 'New card note' # # @see https://developer.github.com/v3/projects/cards/#update-a-project-card # # @api public def update(*args) arguments(args, required: [:card_id]) params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA patch_request("/projects/columns/cards/#{arguments.card_id}", params) end alias edit update # Delete a project card # # @example # github = Github.new # github.projects.cards.delete :card_id # # @see https://developer.github.com/v3/projects/cards/#delete-a-project-card # # @api public def delete(*args) arguments(args, required: [:card_id]) params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA delete_request("/projects/columns/cards/#{arguments.card_id}", params) end alias remove delete # Move a project card # # @param [Hash] params # @option params [String] :position # Required. Required. Can be one of 'first', 'last', or # 'after:', where is the id value of a column in # the same project. # # @example # github = Github.new # github.projects.cards.move :card_id, position: 'bottom' # # @example # github = Github.new # github.projects.cards.move :card_id, position: 'after:', column_id: # # @see https://developer.github.com/v3/projects/cards/#move-a-project-card # # @api public def move(*args) arguments(args, required: [:card_id]) do assert_required REQUIRED_MOVE_CARD_PARAMS end params = arguments.params params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA post_request("/projects/columns/cards/#{arguments.card_id}/moves", params) end end end github_api-0.18.2/lib/github_api/client/users.rb0000644000004100000410000000522713214644262021604 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::Users < API # Load all the modules after initializing Repos to avoid superclass mismatch require_all 'github_api/client/users', 'emails', 'followers', 'keys' VALID_USER_PARAMS_NAMES = %w[ name email blog company location hireable bio ].freeze # Access to Users::Emails API namespace :emails # Access to Users::Followers API namespace :followers # Access to Users::Keys API namespace :keys # List all users. # # This provides a dump of every user, in the order that they signed up # for GitHub. # # @param [Hash] params # @option [Integer] :since # The integer ID of the last User that you’ve seen. # # @example # users = Github::Users.new # users.list # # @api public def list(*args) arguments(args) response = get_request("/users", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single unauthenticated user # # @example # github = Github.new # github.users.get user: 'user-name' # # Get the authenticated user # # @example # github = Github.new oauth_token: '...' # github.users.get # # @api public def get(*args) params = arguments(args).params if user_name = params.delete('user') get_request("/users/#{user_name}", params) else get_request("/user", params) end end alias :find :get # Update the authenticated user # # @param [Hash] params # @option params [String] :name # Optional string # @option params [String] :email # Optional string - publically visible email address # @option params [String] :blog # Optional string # @option params [String] :company # Optional string # @option params [String] :location # Optional string # @option params [String] :hireable # Optional boolean # @option params [String] :bio # Optional string # # @example # github = Github.new oauth_token: '..' # github.users.update # name: "monalisa octocat", # email: "octocat@github.com", # blog: "https://github.com/blog", # company: "GitHub", # location: "San Francisco", # hireable: true, # bio: "There once..." # # @api public def update(*args) arguments(args) do permit VALID_USER_PARAMS_NAMES end patch_request("/user", arguments.params) end end # Users end # Github github_api-0.18.2/lib/github_api/client/search.rb0000644000004100000410000000753313214644262021712 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' require_relative '../utils/url' module Github # The Search API is optimized to help you find the specific item # you're looking for (e.g., a specific user, a specific file # in a repository, etc.). class Client::Search < API include Github::Utils::Url require_all 'github_api/client/search', 'legacy' # Access to Search::Legacy API namespace :legacy # Search issues # # Find issues by state and keyword. # (This method returns up to 100 results per page.) # # @param [Hash] params # @option params [String] :q # The search terms. This can be any combination of the supported # issue search parameters. # @option params [String] :sort # Optional sort field. One of comments, created, or updated. # If not provided, results are sorted by best match. # @option params [String] :order # The sort order if sort parameter is provided. # One of asc or desc. Default: desc # # @example # github = Github.new # github.search.issues 'query' # # @example # github.search.issues q: 'query' # # @api public def issues(*args) params = arguments(args, required: [:q]).params params['q'] ||= arguments.q get_request('/search/issues' , params) end # Search repositories # # Find repositories via various criteria. # (This method returns up to 100 results per page.) # # @param [Hash] params # @option params [String] :q # The search keywords, as well as any qualifiers. # @option params [String] :sort # The sort field. One of stars, forks, or updated. # Default: results are sorted by best match. # @option params [String] :order # The sort order if sort parameter is provided. # One of asc or desc. Default: desc # # @example # github = Github.new # github.search.repos 'query' # # @example # github.search.repos q: 'query' # # @api public def repos(*args) params = arguments(args, required: [:q]).params params['q'] ||= arguments.q get_request('/search/repositories', arguments.params) end alias :repositories :repos # Search users # # Find users by keyword. # # @param [Hash] params # @option params [String] :q # The search terms. This can be any combination of the supported # issue search parameters. # @option params [String] :sort # Optional sort field. One of comments, created, or updated. # If not provided, results are sorted by best match. # @option params [String] :order # The sort order if sort parameter is provided. # One of asc or desc. Default: desc # # @example # github = Github.new # github.search.users q: 'wycats' # # @api public def users(*args) params = arguments(args, required: [:q]).params params['q'] ||= arguments.q get_request('/search/users', arguments.params) end # Find file contents via various criteria. # (This method returns up to 100 results per page.) # # @param [Hash] params # @option params [String] :q # The search terms. This can be any combination of the supported # issue search parameters. # @option params [String] :sort # Optional sort field. One of comments, created, or updated. # If not provided, results are sorted by best match. # @option params [String] :order # The sort order if sort parameter is provided. # One of asc or desc. Default: desc # # @example # github = Github.new # github.search.code q: 'wycats' # # @api public def code(*args) params = arguments(args, required: [:q]).params params['q'] ||= arguments.q get_request('/search/code', params) end end # Search end # Github github_api-0.18.2/lib/github_api/client/pull_requests.rb0000644000004100000410000001410513214644262023345 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github class Client::PullRequests < API require_all 'github_api/client/pull_requests', 'comments', 'reviews' # Access to PullRequests::Comments API namespace :comments # Access to PullRequests::Reviews API namespace :reviews # List pull requests # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.pull_requests.list # github.pull_requests.list { |req| ... } # # @example # pulls = Github::PullRequests.new # pulls.pull_requests.list 'user-name', 'repo-name' # # @api public def list(*args) arguments(args, required: [:user, :repo]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls", arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get a single pull request # # = Examples # github = Github.new # github.pull_requests.get 'user-name', 'repo-name', 'number' # # pulls = Github::PullRequests.new # pulls.get 'user-name', 'repo-name', 'number' # def get(*args) arguments(args, required: [:user, :repo, :number]) get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}", arguments.params) end alias_method :find, :get # Create a pull request # # @param [Hash] params # @option params [String] :title # Required string # @option params [String] :body # Optional string # @option params [String] :base # Required string - The branch you want your changes pulled into. # @option params [String] :head # Required string - The branch where your changes are implemented. # # @note: head and base can be either a sha or a branch name. # Typically you would namespace head with a user like this: username:branch. # # Alternative Input # You can also create a Pull Request from an existing Issue by passing # an Issue number instead of title and body. # @option params [Numeric] :issue # Required number - Issue number in this repository to turn into a Pull Request. # # @example # github = Github.new oauth_token: '...' # github.pull_requests.create 'user-name', 'repo-name', # title: "Amazing new feature", # body: "Please pull this in!", # head: "octocat:new-feature", # base: "master" # # @example # github.pull_requests.create 'user-name', 'repo-name', # issue: "5", # head: "octocat:new-feature", # base: "master" # # @api public def create(*args) arguments(args, required: [:user, :repo]) post_request("/repos/#{arguments.user}/#{arguments.repo}/pulls", arguments.params) end # Update a pull request # # @param [Hash] params # @option params [String] :title # Optional string # @optoin params [String] :body # Optional string # @option params [String] :state # Optional string - State of this Pull Request. # Valid values are open and closed. # # @example # github = Github.new oauth_token: '...' # github.pull_requests.update 'user-name', 'repo-name', 'number' # title: "Amazing new title", # body: "Update body", # state: "open" # # @api public def update(*args) arguments(args, required: [:user, :repo, :number]) patch_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}", arguments.params) end # List commits on a pull request # # @example # github = Github.new # github.pull_requests.commits 'user-name', 'repo-name', 'number' # # @api public def commits(*args) arguments(args, required: [:user, :repo, :number]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/commits", arguments.params) return response unless block_given? response.each { |el| yield el } end # List pull requests files # # @example # github = Github.new # github.pull_requests.files 'user-name', 'repo-name', 'number' # # @api public def files(*args) arguments(args, required: [:user, :repo, :number]) response = get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/files", arguments.params) return response unless block_given? response.each { |el| yield el } end # Check if pull request has been merged # # @example # github = Github.new # github.pull_requests.merged? 'user-name', 'repo-name', 'number' # # @api public def merged?(*args) arguments(args, required: [:user, :repo, :number]) get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/merge", arguments.params) true rescue Github::Error::NotFound false end PREVIEW_MEDIA = 'application/vnd.github.polaris-preview+json'.freeze # :nodoc: # Merge a pull request(Merge Button) # # @param [Hash] params # @option params [String] :commit_title # Optional string - The first line of the message that will be used for the merge commit # @option params [String] :commit_message # Optional string - The message that will be used for the merge commit # @option params [String] :sha # Optional string - The SHA that pull request head must match to allow merge # @option params [String] :merge_method # Optional string - Merge method to use. # Valid values are merge, squash, and rebase. Default is merge. # # @example # github = Github.new # github.pull_requests.merge 'user-name', 'repo-name', 'number' # # @api public def merge(*args) arguments(args, required: [:user, :repo, :number]) params = arguments.params params['accept'] ||= PREVIEW_MEDIA put_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/merge", params) end end # PullRequests end # Github github_api-0.18.2/lib/github_api/client/users/0000755000004100000410000000000013214644262021251 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/users/followers.rb0000644000004100000410000000624313214644262023617 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Users::Followers < API # List a user's followers # # @example # github = Github.new # github.users.followers.list 'user-name' # github.users.followers.list 'user-name' { |user| ... } # # List the authenticated user's followers # # @example # github = Github.new oauth_token: '...' # github.users.followers # github.users.followers { |user| ... } # # @api public def list(*args) params = arguments(args).params response = if user_name = arguments.remaining.first get_request("/users/#{user_name}/followers", params) else get_request("/user/followers", params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # List who a user is following # # @example # github = Github.new # github.users.followers.following 'user-name' # github.users.followers.following 'user-name' { |user| ... } # # List who the authenicated user is following # # @example # github = Github.new oauth_token: '...' # github.users.followers.following # # @api public def following(*args) params = arguments(args).params response = if user_name = arguments.remaining.first get_request("/users/#{user_name}/following", params) else get_request("/user/following", params) end return response unless block_given? response.each { |el| yield el } end # Check if you are following a user # # @example # github = Github.new oauth_token: '...' # github.users.followers.following? 'user-name' # github.users.followers.following? username: 'user-name' # # Check if one user follows another # # @example # github = Github.new oauth_token: '...' # github.users.followers.following? username: 'user-name', # target_user: 'target-user-name' # # @api public def following?(*args) arguments(args, required: [:username]) params = arguments.params if target_user = params.delete('target_user') get_request("/users/#{arguments.username}/following/#{target_user}", params) else get_request("/user/following/#{arguments.username}", params) end true rescue Github::Error::NotFound false end # Follow a user # # @example # github = Github.new oauth_token: '...' # github.users.followers.follow 'user-name' # github.users.followers.follow username: 'user-name' # # @api public def follow(*args) arguments(args, required: [:username]) put_request("/user/following/#{arguments.username}", arguments.params) end # Unfollow a user # # @example # github = Github.new oauth_token: '...' # github.users.followers.unfollow 'user-name' # github.users.followers.unfollow username: 'user-name' # def unfollow(*args) arguments(args, required: [:username]) delete_request("/user/following/#{arguments.username}", arguments.params) end end # Users::Followers end # Github github_api-0.18.2/lib/github_api/client/users/emails.rb0000644000004100000410000000327013214644262023052 0ustar www-datawww-data# encoding: utf-8 require 'cgi' require_relative '../../api' module Github class Client::Users::Emails < API # List email addresses for the authenticated user # # @example # github = Github.new oauth_token: '...' # github.users.emails.list # github.users.emails.list { |email| ... } # # @return [Hash] # # @api public def list(*args) arguments(args) response = get_request("/user/emails", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Add email address(es) for the authenticated user # # @param [Array[String]] emails # You can include a single email address or an array of addresses # # @example # github = Github.new oauth_token: '...' # github.users.emails.add "octocat@github.com", "support@github.com" # # @api public def add(*args) arguments(args) params = arguments.params params['data'] = arguments.remaining unless arguments.remaining.empty? post_request("/user/emails", params) end alias :<< :add # Delete email address(es) for the authenticated user # # @param [Array[String]] emails # You can include a single email address or an array of addresses # # @example # github = Github.new oauth_token: '...' # github.users.emails.delete "octocat@github.com", "support@github.com" # # @api public def delete(*args) arguments(args) params = arguments.params params['data'] = arguments.remaining unless arguments.remaining.empty? delete_request("/user/emails", params) end end # Users::Emails end # Github github_api-0.18.2/lib/github_api/client/users/keys.rb0000644000004100000410000000523413214644262022555 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Users::Keys < API VALID_KEY_PARAM_NAMES = %w[ title key ].freeze # List public keys for the authenticated user # # @example # github = Github.new oauth_token: '...' # github.users.keys.list # github.users.keys.list { |key| ... } # # List public keys for the specified user # # @example # github.users.keys.list user: 'user-name' # github.users.keys.list user: 'user-name' { |key| ... } # # @return [Hash] # # @api public def list(*args) params = arguments(args).params response = if (user = params.delete('user')) get_request("/users/#{user}/keys", params) else get_request("/user/keys", params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single pulic key for the authenticated user # # @example # github = Github.new oauth_token: '...' # github.users.keys.get 'key-id' # # @api public def get(*args) arguments(args, required: [:id]) get_request("/user/keys/#{arguments.id}", arguments.params) end alias :find :get # Create a public key for the authenticated user # # @param [Hash] params # @option [String] :title # Required string # @option [String] :key # Required string. sha key # # @example # github = Github.new oauth_token: '...' # github.users.keys.create "title": "octocat@octomac", "key": "ssh-rsa AAA..." # # @api public def create(*args) arguments(args) do permit VALID_KEY_PARAM_NAMES end post_request("/user/keys", arguments.params) end # Update a public key for the authenticated user # # @param [Hash] params # @option [String] :title # Required string # @option [String] :key # Required string. sha key # # @example # github = Github.new oauth_token: '...' # github.users.keys.update 'key-id', "title": "octocat@octomac", # "key": "ssh-rsa AAA..." # # @api public def update(*args) arguments(args, required: [:id]) do permit VALID_KEY_PARAM_NAMES end patch_request("/user/keys/#{arguments.id}", arguments.params) end # Delete a public key for the authenticated user # # @example # github = Github.new oauth_token: '...' # github.users.keys.delete 'key-id' # # @api public def delete(*args) arguments(args, required: [:id]) delete_request("/user/keys/#{arguments.id}", arguments.params) end end # Users::Keys end # Github github_api-0.18.2/lib/github_api/client/issues/0000755000004100000410000000000013214644262021423 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/client/issues/assignees.rb0000644000004100000410000000454113214644262023735 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Issues::Assignees < API # Lists all the available assignees (owner + collaborators) # to which issues may be assigned. # # @example # Github.issues.assignees.list 'owner', 'repo' # Github.issues.assignees.list 'owner', 'repo' { |assignee| ... } # # @api public def list(*args) arguments(args, required: [:owner, :repo]) response = get_request("/repos/#{arguments.owner}/#{arguments.repo}/assignees", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Check to see if a particular user is an assignee for a repository. # # @example # Github.issues.assignees.check 'user', 'repo', 'assignee' # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.issues.assignees.check 'assignee' # # @api public def check(*args) arguments(args, required: [:owner, :repo, :assignee]) params = arguments.params get_request("/repos/#{arguments.owner}/#{arguments.repo}/assignees/#{arguments.assignee}",params) true rescue Github::Error::NotFound false end # Add assignees to an issue # # @example # github = Github.new # github.issues.assignees.add 'user', 'repo', 'issue-number', # 'hubot', 'other_assignee', ... # # @api public def add(*args) arguments(args, required: [:user, :repo, :number]) params = arguments.params params['data'] = { 'assignees' => arguments.remaining } unless arguments.remaining.empty? post_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}/assignees", params) end alias :<< :add # Remove a assignees from an issue # # @example # github = Github.new # github.issues.assignees.remove 'user', 'repo', 'issue-number', # 'hubot', 'other_assignee' # # @api public def remove(*args) arguments(args, required: [:user, :repo, :number]) params = arguments.params params['data'] = { 'assignees' => arguments.remaining } unless arguments.remaining.empty? delete_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}/assignees", params) end end # Issues::Assignees end # Github github_api-0.18.2/lib/github_api/client/issues/comments.rb0000644000004100000410000001016213214644262023575 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Issues::Comments < API VALID_ISSUE_COMMENT_PARAM_NAME = %w[ body resource mime_type ].freeze # List comments on an issue # # @example # github = Github.new # github.issues.comments.all 'owner-name', 'repo-name', number: 'id' # github.issues.comments.all 'owner-name', 'repo-name', number: 'id' {|com| .. } # @example # github.issues.comments.all owner: 'username', repo: 'repo-name', number: 'id' # # List comments in a repository # # @param [Hash] params # @option params [String] :sort # Optional string, created or updated # @option params [String] :direction # Optional string, asc or desc. Ignored with sort parameter. # @option params [String] :since # Optional string of a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ # # @example # github = Github.new # github.issues.comments.all 'user-name', 'repo-name' # github.issues.comments.all 'user-name', 'repo-name' {|com| .. } # # @api public def list(*args) arguments(args, required: [:user, :repo]) params = arguments.params response = if (number = params.delete('number')) get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{number}/comments", params) else get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/comments", params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single comment # # @example # github = Github.new # github.issues.comments.find 'user-name', 'repo-name', 'id' # # @example # github.issues.comments.find owner: 'user-name', repo: 'repo-name', id: 'id' # def get(*args) arguments(args, required: [:user, :repo, :id]) params = arguments.params get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/comments/#{arguments.id}", params) end alias :find :get # Create a comment # # @param [Hash] params # @option [String] :body # Required string # # @example # github = Github.new # github.issues.comments.create 'user-name', 'repo-name', 'number', # body: 'a new comment' # # @example # github.issues.comments.create # user: 'owner-name', # repo: 'repo-name', # number: 'issue-number', # body: 'a new comment body' # # @api public def create(*args) arguments(args, required: [:user, :repo, :number]) do permit VALID_ISSUE_COMMENT_PARAM_NAME assert_required %w[ body ] end params = arguments.params post_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}/comments", params) end # Edit a comment # # @param [Hash] params # @option params [String] :body # Required string # # @example # github = Github.new # github.issues.comments.edit 'owner-name', 'repo-name', 'id', # body: 'a new comment' # # @example # github.issues.comments.edit # user: 'owner-name', # repo: 'repo-name', # id: 'comment-id', # body: 'a new comment body' # # @api public def edit(*args) arguments(args, required: [:user, :repo, :id]) do permit VALID_ISSUE_COMMENT_PARAM_NAME assert_required %w[ body ] end patch_request("/repos/#{arguments.user}/#{arguments.repo}/issues/comments/#{arguments.id}", arguments.params) end # Delete a comment # # = Examples # github = Github.new # github.issues.comments.delete 'owner-name', 'repo-name', 'comment-id' # # @example # github.issues.comments.delete # user: 'owner-name', # repo: 'repo-name', # id: 'comment-id', # # @api public def delete(*args) arguments(args, required: [:user, :repo, :id]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/issues/comments/#{arguments.id}", arguments.params) end end # Issues::Comments end # Github github_api-0.18.2/lib/github_api/client/issues/milestones.rb0000644000004100000410000001055713214644262024142 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Issues::Milestones < API VALID_MILESTONE_OPTIONS = { 'state' => %w[ open closed all ], 'sort' => %w[ due_date completeness ], 'direction' => %w[ desc asc ] }.freeze # :nodoc: VALID_MILESTONE_INPUTS = %w[ title state description due_on ].freeze # :nodoc: # List milestones for a repository # # @param [Hash] params # @option params [String] :state # The state of the milestone. Either open, closed, or all. Default: open # @option params [String] :sort # What to sort results by. Either due_date or completeness. # Default: due_date # @option params [String] :direction # The directoin of the sort. Either asc or desc. Default: desc # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.issues.milestones.list # # @example # github.issues.milestones.list state: 'open', sort: 'due_date', # direction: 'asc' # # @api public def list(*args) arguments(args, required: [:user, :repo]) do permit VALID_MILESTONE_OPTIONS.keys assert_values VALID_MILESTONE_OPTIONS end response = get_request("/repos/#{arguments.user}/#{arguments.repo}/milestones", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single milestone # # @example # github = Github.new # github.issues.milestones.get 'user-name', 'repo-name', 'milestone-number' # # @example # github.issues.milestones.get # user: 'user-name', # repo: 'repo-name', # number: 'milestone-number' # # @api public def get(*args) arguments(args, required: [:user, :repo, :number]) get_request("/repos/#{arguments.user}/#{arguments.repo}/milestones/#{arguments.number}", arguments.params) end alias :find :get # Create a milestone # # @param [Hash] params # @option params [String] :title # Required string. The title of the milestone # @option params [String] :state # The state of the milestone. Either open or closed. Default: open. # @option params [String] :description # A description of the milestone # @option params [String] :due_on # The milestone due date. This is a timestamp in ISO 8601 format: # YYYY-MM-DDTHH:MM:SSZ. # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.issues.milestones.create title: 'hello-world', # state: "open or closed", # description: "String", # due_on: "Time" # # @api public def create(*args) arguments(args, required: [:user, :repo]) do permit VALID_MILESTONE_INPUTS assert_required %w[ title ] end post_request("/repos/#{arguments.user}/#{arguments.repo}/milestones", arguments.params) end # Update a milestone # # @param [Hash] params # @option params [String] :title # Required string. The title of the milestone # @option params [String] :state # The state of the milestone. Either open or closed. Default: open. # @option params [String] :description # A description of the milestone # @option params [String] :due_on # The milestone due date. This is a timestamp in ISO 8601 format: # YYYY-MM-DDTHH:MM:SSZ. # # @example # github = Github.new # github.issues.milestones.update 'user-name', 'repo-name', 'number', # :title => 'hello-world', # :state => "open or closed", # :description => "String", # :due_on => "Time" # # @api public def update(*args) arguments(args, required: [:user, :repo, :number]) do permit VALID_MILESTONE_INPUTS end patch_request("/repos/#{arguments.user}/#{arguments.repo}/milestones/#{arguments.number}", arguments.params) end # Delete a milestone # # @example # github = Github.new # github.issues.milestones.delete 'user-name', 'repo-name', 'number' # # @api public def delete(*args) arguments(args, required: [:user, :repo, :number]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/milestones/#{arguments.number}", arguments.params) end end # Issues::Milestones end # Github github_api-0.18.2/lib/github_api/client/issues/labels.rb0000644000004100000410000001312513214644262023214 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Issues::Labels < API VALID_LABEL_INPUTS = %w[ name color ].freeze # List all labels for a repository # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.issues.labels.list # github.issues.labels.list { |label| ... } # # Get labels for every issue in a milestone # # @example # github = Github.new # github.issues.labels.list 'user-name', 'repo-name', milestone_id: 'milestone-id' # # List labels on an issue # # @example # github = Github.new # github.issues.labels.list 'user-name', 'repo-name', issue_id: 'issue-id' # # @api public def list(*args) arguments(args, required: [:user, :repo]) params = arguments.params user = arguments.user repo = arguments.repo response = if (milestone_id = params.delete('milestone_id')) get_request("/repos/#{user}/#{repo}/milestones/#{milestone_id}/labels", params) elsif (issue_id = params.delete('issue_id')) get_request("/repos/#{user}/#{repo}/issues/#{issue_id}/labels", params) else get_request("/repos/#{user}/#{repo}/labels", params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single label # # @example # github = Github.new # github.issues.labels.find 'user-name', 'repo-name', 'label-name' # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.issues.labels.get label_name: 'bug' # # @api public def get(*args) arguments(args, required: [:user, :repo, :label_name]) params = arguments.params get_request("/repos/#{arguments.user}/#{arguments.repo}/labels/#{arguments.label_name}", params) end alias :find :get # Create a label # # @param [Hash] params # @option params [String] :name # Required string # @option params [String] :color # Required string - 6 character hex code, without leading # # # @example # github = Github.new user: 'user-name', repo: 'repo-name' # github.issues.labels.create name: 'API', color: 'FFFFFF' # # @api public def create(*args) arguments(args, required: [:user, :repo]) do permit VALID_LABEL_INPUTS assert_required VALID_LABEL_INPUTS end post_request("/repos/#{arguments.user}/#{arguments.repo}/labels", arguments.params) end # Update a label # # @param [Hash] params # @option params [String] :name # Required string # @option params [String] :color # Required string - 6 character hex code, without leading # # # @example # github = Github.new # github.issues.labels.update 'user-name', 'repo-name', 'label-name', # name: 'API', color: "FFFFFF" # # @api public def update(*args) arguments(args, required: [:user, :repo, :label_name]) do permit VALID_LABEL_INPUTS assert_required VALID_LABEL_INPUTS end patch_request("/repos/#{arguments.user}/#{arguments.repo}/labels/#{arguments.label_name}", arguments.params) end alias :edit :update # Delete a label # # @examples # github = Github.new # github.issues.labels.delete 'user-name', 'repo-name', 'label-name' # # @api public def delete(*args) arguments(args, required: [:user, :repo, :label_name]) delete_request("/repos/#{arguments.user}/#{arguments.repo}/labels/#{arguments.label_name}", arguments.params) end # Add labels to an issue # # @example # github = Github.new # github.issues.labels.add 'user-name', 'repo-name', 'issue-number', # 'label1', 'label2', ... # # @api public def add(*args) arguments(args, required: [:user, :repo, :number]) params = arguments.params params['data'] = arguments.remaining unless arguments.remaining.empty? post_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}/labels", params) end alias :<< :add # Remove a label from an issue # # @example # github = Github.new # github.issues.labels.remove 'user-name', 'repo-name', 'issue-number', # label_name: 'label-name' # # Remove all labels from an issue # # @example # github = Github.new # github.issues.labels.remove 'user-name', 'repo-name', 'issue-number' # # @api public def remove(*args) arguments(args, required: [:user, :repo, :number]) params = arguments.params user = arguments.user repo = arguments.repo number = arguments.number if (label_name = params.delete('label_name')) delete_request("/repos/#{user}/#{repo}/issues/#{number}/labels/#{label_name}", params) else delete_request("/repos/#{user}/#{repo}/issues/#{number}/labels", params) end end # Replace all labels for an issue # # Sending an empty array ([]) will remove all Labels from the Issue. # # @example # github = Github.new # github.issues.labels.replace 'user-name', 'repo-name', 'issue-number', # 'label1', 'label2', ... # # @api public def replace(*args) arguments(args, required: [:user, :repo, :number]) params = arguments.params params['data'] = arguments.remaining unless arguments.remaining.empty? put_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}/labels", params) end end # Issues::Labels end # Github github_api-0.18.2/lib/github_api/client/issues/events.rb0000644000004100000410000000254313214644262023260 0ustar www-datawww-data# encoding: utf-8 require_relative '../../api' module Github class Client::Issues::Events < API # List events for an issue # # @example # github = Github.new # github.issues.events.list 'user-name', 'repo-name', # issue_number: 'issue-number' # # List events for a repository # # @example # github = Github.new # github.issues.events.list 'user-name', 'repo-name' # # @api public def list(*args) arguments(args, required: [:user, :repo]) params = arguments.params response = if (issue_number = params.delete('issue_number')) get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{issue_number}/events", params) else get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/events", params) end return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single event # # @example # github = Github.new # github.issues.events.get 'user-name', 'repo-name', 'event-id' # # @api public def get(*args) arguments(args, :required => [:user, :repo, :id]) params = arguments.params get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/events/#{arguments.id}", params) end alias :find :get end # Issues::Events end # Github github_api-0.18.2/lib/github_api/client/authorizations.rb0000644000004100000410000001102413214644262023516 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github # OAuth Authorizations API class Client::Authorizations < API require_all 'github_api/client/authorizations', 'app' # Access to Authorizations::App API namespace :app # List authorizations # # @see https://developer.github.com/v3/oauth_authorizations/#list-your-authorizations # # @example # github = Github.new basic_auth: 'login:password' # github.auth.list # github.auth.list { |auth| ... } # # @api public def list(*args) raise_authentication_error unless authenticated? arguments(args) response = get_request('/authorizations', arguments.params) return response unless block_given? response.each { |el| yield el } end alias_method :all, :list # Get a single authorization # # @see https://developer.github.com/v3/oauth_authorizations/#get-a-single-authorization # # @example # github = Github.new basic_auth: 'login:password' # github.oauth.get 'authorization-id' # # @return [ResponseWrapper] # # @api public def get(*args) raise_authentication_error unless authenticated? arguments(args, required: [:id]) get_request("/authorizations/#{arguments.id}", arguments.params) end alias_method :find, :get # Create a new authorization # # @see https://developer.github.com/v3/oauth_authorizations/#create-a-new-authorization # # @param [Hash] params # @option params [Array[String]] :scopes # A list of scopes that this authorization is in. # @option params [String] :note # Required. A note to remind you what the OAuth token is for. # @option params [String] :note_url # A URL to remind you what the OAuth token is for. # @option params [String] :client_id # The 20 character OAuth app client key for which to create the token. # @option params [String] :client_secret # The 40 character OAuth app client secret for which to create the token. # @option params [String] :fingerprint # A unique string to distinguish an authorization from others # created for the same client ID and user. # # @example # github = Github.new basic_auth: 'login:password' # github.oauth.create scopes: ["public_repo"], note: 'amdmin script' # # @api public def create(*args) raise_authentication_error unless authenticated? arguments(args) do assert_required :note, :scopes end post_request('/authorizations', arguments.params) end # Update an existing authorization # # @see https://developer.github.com/v3/oauth_authorizations/#update-an-existing-authorization # # @param [Hash] inputs # @option inputs [Array] :scopes # Optional array - A list of scopes that this authorization is in. # @option inputs [Array] :add_scopes # Optional array - A list of scopes to add to this authorization. # @option inputs [Array] :remove_scopes # Optional array - A list of scopes to remove from this authorization. # @option inputs [String] :note # Optional string - A note to remind you what the OAuth token is for. # @optoin inputs [String] :note_url # Optional string - A URL to remind you what the OAuth token is for. # @option params [String] :fingerprint # A unique string to distinguish an authorization from others # created for the same client ID and user. # # @example # github = Github.new basic_auth: 'login:password' # github.oauth.update "authorization-id", add_scopes: ["repo"] # # @api public def update(*args) raise_authentication_error unless authenticated? arguments(args, required: [:id]) patch_request("/authorizations/#{arguments.id}", arguments.params) end alias_method :edit, :update # Delete an authorization # # @see https://developer.github.com/v3/oauth_authorizations/#delete-an-authorization # # @example # github = Github.new # github.oauth.delete 'authorization-id' # # @api public def delete(*args) raise_authentication_error unless authenticated? arguments(args, required: [:id]) delete_request("/authorizations/#{arguments.id}", arguments.params) end alias_method :remove, :delete protected def raise_authentication_error raise ArgumentError, 'You can only access your own tokens' \ ' via Basic Authentication' end end # Client::Authorizations end # Github github_api-0.18.2/lib/github_api/client/gitignore.rb0000644000004100000410000000301113214644262022417 0ustar www-datawww-data# encoding: utf-8 require_relative '../api' module Github # When you create a new GitHub repository via the API, you can specify a # .gitignore template to apply to the repository upon creation. class Client::Gitignore < API # List all templates available to pass as an option # when creating a repository. # # @see https://developer.github.com/v3/gitignore/#listing-available-templates # # @example # github = Github.new # github.gitignore.list # github.gitignore.list { |template| ... } # # @api public def list(*args) arguments(args) response = get_request("/gitignore/templates", arguments.params) return response unless block_given? response.each { |el| yield el } end alias :all :list # Get a single template # # @see https://developer.github.com/v3/gitignore/#get-a-single-template # # @example # github = Github.new # github.gitignore.get "template-name" # # Use the raw media type to get the raw contents. # # @examples # github = Github.new # github.gitignore.get "template-name", accept: 'applicatin/vnd.github.raw' # # @api public def get(*args) arguments(args, required: [:name]) params = arguments.params if (media = params.delete('accept')) params['accept'] = media params['raw'] = true end get_request("/gitignore/templates/#{arguments.name}", params) end alias :find :get end # Client::Gitignore end # Github github_api-0.18.2/lib/github_api/version.rb0000644000004100000410000000010313214644262020636 0ustar www-datawww-data# encoding: utf-8 module Github VERSION = "0.18.2" end # Github github_api-0.18.2/lib/github_api/middleware.rb0000644000004100000410000000233613214644262021300 0ustar www-datawww-data# encoding: utf-8 require_relative 'response' require_relative 'response/mashify' require_relative 'response/jsonize' require_relative 'response/atom_parser' require_relative 'response/raise_error' require_relative 'response/header' require_relative 'response/follow_redirects' module Github class Middleware def self.default(options = {}) api = options[:api] proc do |builder| builder.use Github::Request::Jsonize builder.use Faraday::Request::Multipart builder.use Faraday::Request::UrlEncoded builder.use Github::Request::OAuth2, api.oauth_token if api.oauth_token? builder.use Github::Request::BasicAuth, api.authentication if api.basic_authed? builder.use Github::Response::FollowRedirects if api.follow_redirects builder.use Faraday::Response::Logger if ENV['DEBUG'] unless options[:raw] builder.use Github::Response::Mashify builder.use Github::Response::Jsonize builder.use Github::Response::AtomParser end if api.stack api.stack.call(builder) end builder.use Github::Response::RaiseError builder.adapter options[:adapter] end end end # Middleware end # Github github_api-0.18.2/lib/github_api/validations/0000755000004100000410000000000013214644262021147 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/validations/required.rb0000644000004100000410000000122713214644262023316 0ustar www-datawww-data# encoding: utf-8 require_relative '../error/client_error' module Github module Validations module Required # Validate all keys present in a provided hash against required set, # on mismatch raise Github::Error::RequiredParams # Note that keys need to be in the same format i.e. symbols or strings, # otherwise the comparison will fail. # # @api public def assert_required_keys(*required, provided) required.flatten.all? { |key| provided.deep_key?(key.to_s) } || (raise Github::Error::RequiredParams.new(provided, required)) end end # Required end # Validations end # Github github_api-0.18.2/lib/github_api/validations/presence.rb0000644000004100000410000000156313214644262023305 0ustar www-datawww-data# encoding: utf-8 require_relative '../error/client_error' module Github module Validations # A mixin to help validate presence of non-empty values module Presence # Ensure that esential arguments are present before request is made. # # == Parameters # Hash/Array of arguments to be checked against nil and empty string # # == Example # assert_presence_of user: '...', repo: '...' # assert_presence_of user, repo # def assert_presence_of(*args) hash = args.last.is_a?(::Hash) ? args.pop : {} errors = hash.select { |key, val| val.to_s.empty? } raise Github::Error::Validations.new(errors) unless errors.empty? args.each do |arg| raise ArgumentError, "parameter cannot be nil" if arg.nil? end end end # Presence end # Validations end # Github github_api-0.18.2/lib/github_api/validations/token.rb0000644000004100000410000000165713214644262022625 0ustar www-datawww-data# encoding: utf-8 module Github module Validations module Token TOKEN_REQUIRED = [ 'get /user', 'get /user/emails', 'get /user/followers', 'get /user/following', 'get /user/keys', 'get /user/repos', 'patch /user', 'post /user/emails', 'post /user/keys', 'post /user/repos' ] TOKEN_REQUIRED_REGEXP = [ /repos\/.*\/.*\/comments/, ] # Ensures that required authentication token is present before # request is sent. # def validates_token_for(method, path) return true unless TOKEN_REQUIRED.grep("#{method} #{path}").empty? token_required = false TOKEN_REQUIRED_REGEXP.each do |regex| if "#{method} #{path}" =~ regex token_required = true end end return token_required end end # Token end # Validations end # Github github_api-0.18.2/lib/github_api/validations/format.rb0000644000004100000410000000141213214644262022762 0ustar www-datawww-data# encoding: utf-8 require_relative '../error/client_error' module Github module Validations module Format # Ensures that value for a given key is of the correct form whether # matching regular expression or set of predefined values. # def assert_valid_values(permitted, params) params.each do |k, v| next unless permitted.keys.include?(k) if permitted[k].is_a?(Array) && !permitted[k].include?(params[k]) raise Github::Error::UnknownValue.new(k,v, permitted[k].join(', ')) elsif permitted[k].is_a?(Regexp) && !(permitted[k] =~ params[k]) raise Github::Error::UnknownValue.new(k,v, permitted[k]) end end end end # Format end # Validations end # Github github_api-0.18.2/lib/github_api/error/0000755000004100000410000000000013214644262017763 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/error/client_error.rb0000644000004100000410000000637013214644262023005 0ustar www-datawww-data# encoding: utf-8 require_relative '../error' module Github #:nodoc # Raised when Github returns the HTTP status code 404 module Error class ClientError < GithubError attr_reader :problem, :summary, :resolution def initialize(message) super(message) end def generate_message(attributes) @problem = attributes[:problem] @summary = attributes[:summary] @resolution = attributes[:resolution] "\nProblem:\n #{@problem}"+ "\nSummary:\n #{@summary}"+ "\nResolution:\n #{@resolution}" end end # Raised when invalid options are passed to a request body class InvalidOptions < ClientError def initialize(invalid, valid) super( generate_message( problem: "Invalid option #{invalid.keys.join(', ')} provided for this request.", summary: "Github gem checks the request parameters passed to ensure that github api is not hit unnecessarily and to fail fast.", resolution: "Valid options are: #{valid.join(', ')}, make sure these are the ones you are using" ) ) end end # Raised when invalid options are passed to a request body class RequiredParams < ClientError def initialize(provided, required) super( generate_message( problem: "Missing required parameters: #{provided.keys.join(', ')} provided for this request.", summary: "Github gem checks the request parameters passed to ensure that github api is not hit unnecessarily and to fail fast.", resolution: "Required parameters are: #{required.join(', ')}, make sure these are the ones you are using" ) ) end end # Raised when invalid options are passed to a request body class UnknownMedia < ClientError def initialize(file) super( generate_message( problem: "Unknown content type for: '#{file}' provided for this request.", summary: "Github gem infers the content type of the resource by calling the mime-types gem type inference.", resolution: "Please install mime-types gem to infer the resource content type." ) ) end end # Raised when invalid options are passed to a request body class UnknownValue < ClientError def initialize(key, value, permitted) super( generate_message( problem: "Wrong value of '#{value}' for the parameter: #{key} provided for this request.", summary: "Github gem checks the request parameters passed to ensure that github api is not hit unnecessairly and fails fast.", resolution: "Permitted values are: #{permitted}, make sure these are the ones you are using" ) ) end end class Validations < ClientError def initialize(errors) super( generate_message( problem: "Attempted to send request with nil arguments for #{errors.keys.join(', ')}.", summary: 'Each request expects certain number of required arguments.', resolution: 'Double check that the provided arguments are set to some value that is neither nil nor empty string.' ) ) end end end # Error end # Github github_api-0.18.2/lib/github_api/error/service_error.rb0000644000004100000410000001261413214644262023165 0ustar www-datawww-data# encoding: utf-8 require 'json' require_relative '../error' module Github # Raised when GitHub returns any of the HTTP status codes module Error class ServiceError < GithubError # Add http status code method to error type # # @param [Integer] code # the status code # # @api public def self.http_status_code(code) define_method(:http_status_code) { code } end # A mapping of status codes and error types # # @return [Hash[Integer, Object]] # # @api public def self.error_mapping @error_mapping ||= Hash[ descendants.map do |klass| [klass.new({}).http_status_code, klass] end ] end MIN_BODY_LENGTH = 2 # Crate a ServiceError # # @param [Hash[Symbol]] response # # @api public def initialize(response) @headers = response[:response_headers] @body = response[:body] @status = response[:status] @response_headers = @headers @response_message = @body super(create_message(response)) end # Expose response payload as JSON object if possible # # @return [Hash[Symbol]|String] # # @api public def data @data ||= decode_data(@body) end # Stores error message(s) returned in response body # # @return [Array[Hash[Symbol]]] # the array of hash error objects # # @api public def error_messages @error_messages ||= begin data[:errors] ? data[:errors] : [data] end end private # Create full error message # # @param [Hash[Symbol]] response # the http response # # @return [String] # the error message # # @api private def create_message(response) return if response.nil? message = "#{response[:method].to_s.upcase} " message << "#{response[:url]}: " message << "#{@status} - #{format_response}" message end # Decode body information if in JSON format # # @param [String] body # the response body # # @api private def decode_data(body) if body.respond_to?(:to_str) && body.length >= MIN_BODY_LENGTH && @headers[:content_type] =~ /json/ JSON.parse(body, symbolize_names: true) else body end end # Read response body and convert to human friendly format # # @return [String] # # @api private def format_response return '' if data.nil? || data.empty? case data when Hash message = data[:message] ? data[:message] : ' ' docs = data[:documentation_url] error = create_error_summary message << error if error message << "\nSee: #{docs}" if docs message when String data end end # Create error summary from response body # # @return [String] # # @api private def create_error_summary if data[:error] "\nError: #{data[:error]}" elsif data[:errors] message = "\nErrors:\n" message << data[:errors].map do |error| case error when Hash "Error: #{error.map { |k, v| "#{k}: #{v}" }.join(', ')}" else "Error: #{error}" end end.join("\n") end end end # ServiceError # Raised when Github returns the HTTP status code 400 class BadRequest < ServiceError http_status_code 400 end # Raised when GitHub returns the HTTP status code 401 class Unauthorized < ServiceError http_status_code 401 end # Raised when Github returns the HTTP status code 403 class Forbidden < ServiceError http_status_code 403 end # Raised when Github returns the HTTP status code 404 class NotFound < ServiceError http_status_code 404 end # Raised when Github returns the HTTP status code 405 class MethodNotAllowed < ServiceError http_status_code 405 end # Raised when Github returns the HTTP status code 406 class NotAcceptable < ServiceError http_status_code 406 end # Raised when GitHub returns the HTTP status code 409 class Conflict < ServiceError http_status_code 409 end # Raised when GitHub returns the HTTP status code 414 class UnsupportedMediaType < ServiceError http_status_code 414 end # Raised when GitHub returns the HTTP status code 422 class UnprocessableEntity < ServiceError http_status_code 422 end # Raised when GitHub returns the HTTP status code 451 class UnavailableForLegalReasons < ServiceError http_status_code 451 end # Raised when Github returns the HTTP status code 500 class InternalServerError < ServiceError http_status_code 500 end # Raised when Github returns the HTTP status code 501 class NotImplemented < ServiceError http_status_code 501 end # Raised when Github returns the HTTP status code 502 class BadGateway < ServiceError http_status_code 502 end # Raised when GitHub returns the HTTP status code 503 class ServiceUnavailable < ServiceError http_status_code 503 end end # Error end # Github github_api-0.18.2/lib/github_api/paged_request.rb0000644000004100000410000000210613214644262022006 0ustar www-datawww-data# encoding: utf-8 require_relative 'constants' module Github # A module that adds http get request to response pagination module PagedRequest include Github::Constants FIRST_PAGE = 1 # Default request page if none provided PER_PAGE = 30 # Default number of items as specified by API NOT_FOUND = -1 # Either page or per_page parameter not present # Check if current api instance has default per_page param set, # otherwise use global default. # def default_page_size current_api.per_page ? current_api.per_page : PER_PAGE end def default_page current_api.page ? current_api.page : FIRST_PAGE end # Perform http get request with pagination parameters # def page_request(path, params={}) if params[PARAM_PER_PAGE] == NOT_FOUND params[PARAM_PER_PAGE] = default_page_size end if params[PARAM_PAGE] && params[PARAM_PAGE] == NOT_FOUND params[PARAM_PAGE] = default_page end current_api.get_request(path, ParamsHash.new(params)) end end # PagedRequest end # Github github_api-0.18.2/lib/github_api/resource.rb0000644000004100000410000000024413214644262021006 0ustar www-datawww-data module Github class Resource < API def call(*args) method = args.shift template = response = request(method, ) end end end github_api-0.18.2/lib/github_api/page_links.rb0000644000004100000410000000322713214644262021277 0ustar www-datawww-data# encoding: utf-8 require_relative 'constants' module Github # Determines the links in the current response link header to be used # to find the links to other pages of request responses. These will # only be present if the result set size exceeds the per page limit. # # @api private class PageLinks include Github::Constants DELIM_LINKS = ','.freeze # :nodoc: # Hold the extracted values for URI from the Link header # for the first, last, next and previous page. attr_accessor :first, :last, :next, :prev LINK_REGEX = /<([^>]+)>; rel=\"([^\"]+)\"/ # Parses links from executed request # # @param [Hash] response_headers # # @api private def initialize(response_headers) link_header = response_headers[HEADER_LINK] if link_header && link_header =~ /(next|first|last|prev)/ extract_links(link_header) else # When on the first page self.next = response_headers[HEADER_NEXT] self.last = response_headers[HEADER_LAST] end end private def extract_links(link_header) link_header.split(DELIM_LINKS).each do |link| LINK_REGEX.match(link.strip) do |match| url_part, meta_part = match[1], match[2] next if !url_part || !meta_part assign_url_part(meta_part, url_part) end end end def assign_url_part(meta_part, url_part) case meta_part when META_FIRST self.first = url_part when META_LAST self.last = url_part when META_NEXT self.next = url_part when META_PREV self.prev = url_part end end end # PageLinks end # Github github_api-0.18.2/lib/github_api/validations.rb0000644000004100000410000000065713214644262021504 0ustar www-datawww-data# encoding: utf-8 require_relative 'validations/format' require_relative 'validations/presence' require_relative 'validations/required' require_relative 'validations/token' module Github module Validations include Presence include Format include Token include Required VALID_API_KEYS = [ 'page', 'per_page', 'auto_pagination', 'jsonp_callback' ] end # Validation end # Github github_api-0.18.2/lib/github_api/constants.rb0000644000004100000410000000214413214644262021174 0ustar www-datawww-datamodule Github module Constants extend self # Response headers RATELIMIT_REMAINING = 'X-RateLimit-Remaining'.freeze RATELIMIT_LIMIT = 'X-RateLimit-Limit'.freeze RATELIMIT_RESET = 'X-RateLimit-Reset'.freeze CONTENT_TYPE = 'Content-Type'.freeze CONTENT_LENGTH = 'content-length'.freeze CACHE_CONTROL = 'cache-control'.freeze ETAG = 'ETag'.freeze SERVER = 'Server'.freeze DATE = 'Date'.freeze LOCATION = 'Location'.freeze USER_AGENT = 'User-Agent'.freeze ACCEPT = 'Accept'.freeze ACCEPT_CHARSET = 'Accept-Charset'.freeze OAUTH_SCOPES = 'X-OAuth-Scopes'.freeze ACCEPTED_OAUTH_SCOPES = 'X-Accepted-Oauth-Scopes'.freeze # Link headers HEADER_LINK = "Link".freeze HEADER_NEXT = "X-Next".freeze HEADER_LAST = "X-Last".freeze META_REL = "rel".freeze META_LAST = "last".freeze META_NEXT = "next".freeze META_FIRST = "first".freeze META_PREV = "prev".freeze PARAM_PAGE = "page".freeze PARAM_PER_PAGE = "per_page".freeze PARAM_START_PAGE = "start_page".freeze end # Constants end # Github github_api-0.18.2/lib/github_api/requestable.rb0000644000004100000410000000363713214644262021504 0ustar www-datawww-data# encoding: utf-8 module Github # Defines HTTP verbs module Request METHODS = [:get, :post, :put, :delete, :patch] METHODS_WITH_BODIES = [ :post, :put, :patch ] def get_request(path, params={}, options={}) request(:get, path, params, options) end def patch_request(path, params={}, options={}) request(:patch, path, params, options) end def post_request(path, params={}, options={}) request(:post, path, params, options) end def put_request(path, params={}, options={}) request(:put, path, params, options) end def delete_request(path, params={}, options={}) request(:delete, path, params, options) end def request(method, path, params, options) if !METHODS.include?(method) raise ArgumentError, "unkown http method: #{method}" end # _extract_mime_type(params, options) puts "EXECUTED: #{method} - #{path} with #{params} and #{options}" if ENV['DEBUG'] conn = connection(options) path = (conn.path_prefix + path).gsub(/\/\//,'/') if conn.path_prefix != '/' response = conn.send(method) do |request| case method.to_sym when *(METHODS - METHODS_WITH_BODIES) request.body = params.delete('data') if params.has_key?('data') request.url(path, params) when *METHODS_WITH_BODIES request.path = path request.body = extract_data_from_params(params) unless params.empty? end end response.body end private def extract_data_from_params(params) # :nodoc: return params['data'] if params.has_key?('data') and !params['data'].nil? return params end def _extract_mime_type(params, options) # :nodoc: options['resource'] = params['resource'] ? params.delete('resource') : '' options['mime_type'] = params['resource'] ? params.delete('mime_type') : '' end end # Request end # Github github_api-0.18.2/lib/github_api/request/0000755000004100000410000000000013214644262020322 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/request/verbs.rb0000644000004100000410000000316313214644262021773 0ustar www-datawww-data# encoding: utf-8 require_relative '../request' require_relative '../params_hash' module Github # A class responsible for dispatching http requests class Request # Defines HTTP verbs module Verbs # Make a head request # # @api public def head_request(path, params = ParamsHash.empty) Request.new(:head, path, self).call(current_options, params) end # Make a get request # # @api public def get_request(path, params = ParamsHash.empty) request = Request.new(:get, path, self).call(current_options, params) request.auto_paginate end # Make a patch request # # @api public def patch_request(path, params = ParamsHash.empty) Request.new(:patch, path, self).call(current_options, params) end # Make a post request # # @api public def post_request(path, params = ParamsHash.empty) Request.new(:post, path, self).call(current_options, params) end # Make a put request # # @api public def put_request(path, params = ParamsHash.empty) Request.new(:put, path, self).call(current_options, params) end # Make a delete request # # @api public def delete_request(path, params = ParamsHash.empty) Request.new(:delete, path, self).call(current_options, params) end # Make a options request # # @api public def options_request(path, params = ParamsHash.empty) Request.new(:options, path, self).call(current_options, params) end end # Verbs end # Request end # Github github_api-0.18.2/lib/github_api/request/basic_auth.rb0000644000004100000410000000142313214644262022751 0ustar www-datawww-data# encoding: utf-8 require 'faraday' require 'base64' module Github class Request class BasicAuth < Faraday::Middleware dependency 'base64' # @api private def initialize(app, *args) @app = app @auth = nil options = args.extract_options! if options.key?(:login) && !options[:login].nil? credentials = "#{options[:login]}:#{options[:password]}" @auth = Base64.encode64(credentials) @auth.gsub!("\n", "") end end # Update request headers # # @api private def call(env) if @auth env[:request_headers].merge!('Authorization' => "Basic #{@auth}") end @app.call(env) end end # BasicAuth end # Request end # Github github_api-0.18.2/lib/github_api/request/jsonize.rb0000644000004100000410000000246513214644262022337 0ustar www-datawww-data# encoding: utf-8 require 'faraday' module Github class Request::Jsonize < Faraday::Middleware CONTENT_TYPE = 'Content-Type'.freeze MIME_TYPE = 'application/json'.freeze dependency 'multi_json' def call(env) if request_with_body?(env) env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE env[:body] = encode_body env[:body] unless env[:body].respond_to?(:to_str) elsif safe_to_modify?(env) # Ensure valid body for put and post requests if [:put, :patch, :post].include?(env[:method]) env[:body] = encode_body({}) end end @app.call env end def encode_body(value) if MultiJson.respond_to?(:dump) MultiJson.dump(value) else MultiJson.encode(value) end end def request_with_body?(env) has_body?(env) and safe_to_modify?(env) end def safe_to_modify?(env) type = request_type(env) type.empty? or type == MIME_TYPE end # Don't encode bodies in string form def has_body?(env) body = env[:body] and !(body.respond_to?(:to_str) and body.empty?) end def request_type(env) type = env[:request_headers][CONTENT_TYPE].to_s type = type.split(';', 2).first if type.index(';') type end end # Request::Jsonize end # Github github_api-0.18.2/lib/github_api/request/oauth2.rb0000644000004100000410000000170113214644262022050 0ustar www-datawww-data# encoding: utf-8 require 'faraday' require_relative '../utils/url' module Github class Request class OAuth2 < Faraday::Middleware include Github::Utils::Url ACCESS_TOKEN = 'access_token'.freeze AUTH_HEADER = 'Authorization'.freeze dependency 'oauth2' def call(env) # Extract parameters from the query params = { ACCESS_TOKEN => @token }.update query_params(env[:url]) if token = params[ACCESS_TOKEN] and !token.empty? env[:url].query = build_query params env[:request_headers].merge!(AUTH_HEADER => "token #{token}") end @app.call env end def initialize(app, *args) super app @app = app @token = args.shift end def query_params(url) if url.query.nil? or url.query.empty? {} else parse_query url.query end end end # OAuth2 end # Request end # Github github_api-0.18.2/lib/github_api/utils/0000755000004100000410000000000013214644262017772 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/utils/url.rb0000644000004100000410000000267713214644262021135 0ustar www-datawww-data# encoding:utf-8 require 'cgi' require 'addressable/uri' module Github module Utils module Url extend self DEFAULT_QUERY_SEP = /[&;] */n KEY_VALUE_SEP = '='.freeze def escape_uri(s) Addressable::URI.escape(s.to_s) end def escape(s) CGI.escape(s.to_s) end def unescape(s) CGI.unescape(s.to_s) end def normalize(s) Addressable::URI.parse(s.to_s).normalize.path end def build_query(params) params.map { |k, v| if v.class == Array build_query(v.map { |x| [k, x] }) else v.nil? ? escape(k) : "#{escape(k)}=#{escape(v)}" end }.join("&") end def parse_query(query_string) return '' if query_string.nil? || query_string.empty? params = {} query_string.split(DEFAULT_QUERY_SEP).each do |part| k, v = part.split(KEY_VALUE_SEP, 2).map { |el| unescape(el) } if cur = params[k] if cur.class == Array params[k] << v else params[k] = [cur, v] end else params[k] = v end end params end def parse_query_for_param(query_string, name) parse_query(query_string).each do |key, val| return val.first if (name == key) && val.is_a?(Array) return val if (name == key) end return nil end end # Url end # Utils end # Github github_api-0.18.2/lib/github_api/authorization.rb0000644000004100000410000000416713214644262022067 0ustar www-datawww-data# encoding: utf-8 require 'oauth2' module Github module Authorization # Setup OAuth2 instance def client @client ||= ::OAuth2::Client.new(client_id, client_secret, { :site => current_options.fetch(:site) { Github.site }, :authorize_url => 'login/oauth/authorize', :token_url => 'login/oauth/access_token', :ssl => { :verify => false } } ) end # Strategy token def auth_code _verify_client client.auth_code end # Sends authorization request to GitHub. # = Parameters # * :redirect_uri - Optional string. # * :scope - Optional string. Comma separated list of scopes. # Available scopes: # * (no scope) - public read-only access (includes public user profile info, public repo info, and gists). # * user - DB read/write access to profile info only. # * public_repo - DB read/write access, and Git read access to public repos. # * repo - DB read/write access, and Git read access to public and private repos. # * gist - write access to gists. # def authorize_url(params = {}) _verify_client client.auth_code.authorize_url(params) end # Makes request to token endpoint and retrieves access token value def get_token(authorization_code, params = {}) _verify_client client.auth_code.get_token(authorization_code, params) end # Check whether authentication credentials are present def authenticated? basic_authed? || oauth_token? end # Check whether basic authentication credentials are present def basic_authed? basic_auth? || (login? && password?) end # Select authentication parameters # # @api public def authentication if basic_authed? { login: login, password: password } else {} end end private def _verify_client # :nodoc: raise ArgumentError, 'Need to provide client_id and client_secret' unless client_id? && client_secret? end end # Authorization end # Github github_api-0.18.2/lib/github_api/params_hash.rb0000644000004100000410000000450313214644262021447 0ustar www-datawww-data# encoding: utf-8 require 'delegate' require 'base64' require_relative 'normalizer' require_relative 'mime_type' module Github # Class responsible for holding request parameters class ParamsHash < DelegateClass(Hash) include Normalizer include MimeType REQUEST_PARAMS = [:accept, :media, :data, :raw, :headers] def initialize(hash) super(normalize!(Hash[hash])) end # Create empty hash # # @api public def self.empty new({}) end # Extract and parse media type param # # [.version].param[+json] # # @api public def media parse(delete('media')) end # Get accept header # # @api public def accept if key?('accept') then self['accept'] elsif key?('media') then media else nil end end # Extract request data from parameters # # @api public def data if key?('data') && !self['data'].nil? self['data'] else request_params end end def encoder if key?('encoder') && self['encoder'] self['encoder'] else {} end end # Configuration options from request # # @return [Hash] # # @api public def options opts = fetch('options', {}) headers = fetch('headers', {}) if value = accept headers[:accept] = value end opts[:raw] = key?('raw') ? self['raw'] : false opts[:headers] = headers unless headers.empty? opts end # Update hash with default parameters for non existing keys # def merge_default(defaults) if defaults && !defaults.empty? defaults.each do |key, value| self[key] = value unless self.key?(key) end end self end # Base64 encode string removing newline characters # # @api public def strict_encode64(key) value = self[key] encoded = if Base64.respond_to?(:strict_encode64) Base64.strict_encode64(value) else [value].pack('m0') end self[key] = encoded.delete("\n\r") end # Filter out request params # # @api public def request_params to_hash.select do |key, value| !REQUEST_PARAMS.include?(key.to_sym) end end end # ParamsHash end # Github github_api-0.18.2/lib/github_api/normalizer.rb0000644000004100000410000000103113214644262021334 0ustar www-datawww-data# frozen_string_literal: true # encoding: utf-8 module Github # Normalize client-supplied parameter keys. module Normalizer # Turns any keys from nested hashes including nested arrays into strings def normalize!(params) case params when Hash params.keys.each do |k| params[k.to_s] = params.delete(k) normalize!(params[k.to_s]) end when Array params.map! do |el| normalize!(el) end end params end end # Normalizer end # Github github_api-0.18.2/lib/github_api/ext/0000755000004100000410000000000013214644262017432 5ustar www-datawww-datagithub_api-0.18.2/lib/github_api/ext/faraday.rb0000644000004100000410000000177413214644262021377 0ustar www-datawww-data# encoding: utf-8 module Faraday module Utils class ParamsHash def params_encoder(encoder = nil) if encoder @encoder = encoder elsif defined?(@encoder) @encoder end end def to_query(encoder = nil) Utils.build_nested_query(self, nil, params_encoder) end end def build_nested_query(value, prefix = nil, encoder = nil) case value when Array value.map { |v| build_nested_query(v, "#{prefix}%5B%5D", encoder) }.join("&") when Hash value.map { |k, v| processed_value = encoder ? encoder.escape(k) : escape(k) build_nested_query(v, prefix ? "#{prefix}%5B#{processed_value}%5D" : processed_value, encoder) }.join("&") when NilClass prefix else raise ArgumentError, "value must be a Hash" if prefix.nil? processed_value = encoder ? encoder.escape(value) : escape(value) "#{prefix}=#{processed_value}" end end end end github_api-0.18.2/lib/github_api/error.rb0000644000004100000410000000125613214644262020314 0ustar www-datawww-data# encoding: utf-8 require 'descendants_tracker' module Github module Error class GithubError < StandardError extend DescendantsTracker attr_reader :response_message, :response_headers # Initialize a new Github error object. # def initialize(message = $!) if message.respond_to?(:backtrace) super(message.message) @response_message = message else super(message.to_s) end end def backtrace if @response_message.respond_to?(:backtrace) @response_message.backtrace else super end end end # GithubError end # Error end # Github github_api-0.18.2/lib/github_api/null_encoder.rb0000644000004100000410000000074613214644262021637 0ustar www-datawww-data# encoding: utf-8 require 'faraday' module Github # Skip encoding of the key nested parameters module NullParamsEncoder if defined?(Faraday::NestedParamsEncoder) class << self Faraday::NestedParamsEncoder.singleton_methods do |m| define_method m, ::Faraday::NestedParamsEncoder.method(m).to_proc end end end def self.escape(s) s.to_s end def self.unescape(s) s.to_s end end # NullEncoder end # Github github_api-0.18.2/lib/github_api/response_wrapper.rb0000644000004100000410000000632013214644262022556 0ustar www-datawww-data# encoding: utf-8 require 'forwardable' require_relative 'pagination' module Github # A class responsible for proxing to faraday response class ResponseWrapper extend Forwardable include Pagination include Enumerable attr_reader :response attr_reader :current_api attr_reader :env def_delegators :body, :empty?, :size, :include?, :length, :to_a, :first, :flatten, :include?, :keys, :[] def initialize(response, current_api) @response = response @current_api = current_api @env = response.env @body = nil end # Overwrite methods to hash keys # ['id', 'type', 'fork'].each do |method_name| define_method(method_name) do self.body.fetch(method_name.to_s) end end # Request url # def url response.env[:url].to_s end def body=(value) @body = value @env[:body] = value end # Response raw body # def body @body ? @body : response.body end # Response status # def status response.status end def success? response.success? end def redirect? status.to_i >= 300 && status.to_i < 400 end def client_error? status.to_i >= 400 && status.to_i < 500 end def server_error? status.to_i >= 500 && status.to_i < 600 end # Return response headers # def headers Github::Response::Header.new(env) end # Lookup an attribute from the body if hash, otherwise behave like array index. # Convert any key to string before calling. # def [](key) if self.body.is_a?(Array) self.body[key] else self.body.send(:"#{key}") end end # Return response body as string # def to_s body.to_s end # Convert the ResponseWrapper into a Hash # def to_hash body.to_hash end # Convert the ResponseWrapper into an Array # def to_ary body.to_ary end # Iterate over each resource inside the body # def each body_parts = self.body.respond_to?(:each) ? self.body : [self.body] return body_parts.to_enum unless block_given? body_parts.each { |part| yield(part) } end # Check if body has an attribute # def has_key?(key) self.body.is_a?(Hash) && self.body.has_key?(key) end # Coerce any method calls for body attributes # def method_missing(method_name, *args, &block) if self.has_key?(method_name.to_s) self.[](method_name, &block) else super end end # Check if method is defined on the body # def respond_to?(method_name, include_all = false) if self.has_key?(method_name.to_s) true else super end end # Print only response body # def inspect "#<#{self.class.name} @body=\"#{self.body}\">" end # Compare the wrapper with other wrapper for equality # def ==(other) return false unless other.is_a?(self.class) return false unless (other.respond_to?(:env) && other.respond_to?(:body)) self.env == other.env && self.body == other.body end alias eql? == end # ResponseWrapper end # Github github_api-0.18.2/lib/github_api.rb0000644000004100000410000000425213214644262017162 0ustar www-datawww-data# encoding: utf-8 require 'pp' if ENV['DEBUG'] require 'faraday' require_relative 'github_api/ext/faraday' module Github LIBNAME = 'github_api' LIBDIR = File.expand_path("../#{LIBNAME}", __FILE__) class << self # The client configuration # # @return [Configuration] # # @api public def configuration @configuration ||= Configuration.new end alias_method :config, :configuration # Configure options # # @example # Github.configure do |c| # c.some_option = true # end # # @yield the configuration block # @yieldparam configuration [Github::Configuration] # the configuration instance # # @return [nil] # # @api public def configure yield configuration end # Alias for Github::Client.new # # @param [Hash] options # the configuration options # # @return [Github::Client] # # @api public def new(options = {}, &block) Client.new(options, &block) end # Default middleware stack that uses default adapter as specified # by configuration setup # # @return [Proc] # # @api private def default_middleware(options = {}) Middleware.default(options) end # Delegate to Github::Client # # @api private def method_missing(method_name, *args, &block) if new.respond_to?(method_name) new.send(method_name, *args, &block) elsif configuration.respond_to?(method_name) Github.configuration.send(method_name, *args, &block) else super end end def respond_to?(method_name, include_private = false) new.respond_to?(method_name, include_private) || configuration.respond_to?(method_name) || super(method_name, include_private) end end end # Github require_relative 'github_api/api' require_relative 'github_api/client' require_relative 'github_api/configuration' require_relative 'github_api/deprecation' require_relative 'github_api/core_ext/array' require_relative 'github_api/core_ext/hash' require_relative 'github_api/core_ext/ordered_hash' require_relative 'github_api/middleware' require_relative 'github_api/version' github_api-0.18.2/README.md0000644000004100000410000006034013214644262015233 0ustar www-datawww-data
github api logo
# GithubAPI [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter] [![Gem Version](https://badge.fury.io/rb/github_api.svg)][gem] [![Build Status](https://secure.travis-ci.org/piotrmurach/github.svg?branch=master)][travis] [![Code Climate](https://codeclimate.com/github/piotrmurach/github/badges/gpa.svg)][codeclimate] [![Coverage Status](https://coveralls.io/repos/piotrmurach/github/badge.svg?branch=master)][coverage] [![Inline docs](http://inch-ci.org/github/piotrmurach/github.svg)][inchpages] [![Dependency Status](https://gemnasium.com/piotrmurach/github.svg?travis)][gemnasium] [gitter]: https://gitter.im/piotrmurach/github_api [gem]: http://badge.fury.io/rb/github_api [travis]: http://travis-ci.org/piotrmurach/github [codeclimate]: https://codeclimate.com/github/piotrmurach/github [coverage]: https://coveralls.io/r/piotrmurach/github [inchpages]: http://inch-ci.org/github/piotrmurach/github [gemnasium]: https://gemnasium.com/piotrmurach/github [Website](http://piotrmurach.github.io/github/) | [Wiki](https://github.com/piotrmurach/github/wiki) | [RDocs](http://rubydoc.info/github/piotrmurach/github/master/frames) A Ruby client for the official GitHub API. Supports all the API methods. It's built in a modular way. You can either instantiate the whole API wrapper Github.new or use parts of it i.e. Github::Client::Repos.new if working solely with repositories is your main concern. Intuitive query methods allow you easily call API endpoints. ## Features * Intuitive GitHub API interface navigation. * It's comprehensive. You can request all GitHub API resources. * Modular design allows for working with parts of API. * Fully customizable including advanced middleware stack construction. * Supports OAuth2 authorization. * Flexible argument parsing. You can write expressive and natural queries. * Requests pagination with convenient DSL and automatic options. * Easy error handling split for client and server type errors. * Supports multithreaded environment. * Custom media type specification through the 'media' parameter. * Request results caching * Fully tested with unit and feature tests hitting the live api. ## Installation Install the gem by running ```ruby gem install github_api ``` or put it in your Gemfile and run `bundle install` ```ruby gem "github_api" ``` ## Contents * [1. Usage](#1-usage) * [1.1 API Navigation](#11-api-navigation) * [1.2 Modularity](#12-modularity) * [1.3 Arguments](#13-arguments) * [1.4 Response Querying](#14-response-querying) * [1.4.1 Response Body](#141-response-body) * [1.4.2 Response Headers](#142-response-headers) * [1.4.3 Response Success](#143-response-success) * [1.5 Request Headers](#15-request-headers) * [1.5.1 Media Types](#151-media-types) * [2. Configuration](#2-configuration) * [2.1 Basic](#21-basic) * [2.2 Advanced](#22-advanced) * [2.3 SSL](#23-ssl) * [2.4 Caching](#24-caching) * [3. Authentication](#3-authentication) * [3.1 Basic](#31-basic) * [3.2 Authorizations API](#32-authorizations-api) * [3.3 Scopes](#33-scopes) * [3.4 Application OAuth](#34-application-oauth) * [3.5 Two-Factor](#35-two-factor) * [4. Pagination](#4-pagination) * [4.1 Auto pagination](#41-auto-pagination) * [5. Error Handling](#5-error-handling) * [5.1 Client Error](#51-client-error) * [5.2 Service Error](#52-service-error) * [5.2.1 Data](#521-data) * [5.2.2 Error Messages](#522-error-messages) * [6. Examples](#6-examples) * [6.1 Rails](#61-rails) * [6.2 Manipulating Files](#62-manipulating-files) * [7. Testing](#7-testing) ## 1 Usage To start using the gem, you can either perform requests directly on `Github` namespace: ```ruby Github.repos.list user: 'piotrmurach' ``` or create a new client instance like so ```ruby github = Github.new ``` and then call api methods, for instance, to list a given user repositories do ```ruby github.repos.list user: 'piotrmurach' ``` ### 1.1 API Navigation The **github_api** closely mirrors the [GitHub API](https://developer.github.com/v3/) hierarchy. For example, if you want to create a new file in a repository, look up the GitHub API spec. In there you will find contents sub category underneath the repository category. This would translate to the request: ```ruby github = Github.new github.repos.contents.create 'piotrmurach', 'finite_machine', 'hello.rb', path: 'hello.rb', content: "puts 'hello ruby'" ``` The whole library reflects the same api navigation. Therefore, if you need to list releases for a repository do: ```ruby github.repos.releases.list 'piotrmurach', 'finite_machine' ``` or to list a user's followers: ```ruby github.users.followers.list 'piotrmurach' ``` The code base has been extensively documented with examples of how to use each method. Please refer to the [documentation](http://rubydoc.info/github/piotrmurach/github/master/frames) under the `Github::Client` class name. Alternatively, you can find out which methods are supported by an api by calling `actions` on a class or instance. For example, in order to find out available endpoints for `Github::Client::Repos::Contents` api call `actions` method: ```ruby Github::Client::Repos::Contents.actions => [:archive, :create, :delete, :find, :get, :readme, :update] ``` ### 1.2 Modularity The code base is modular. This means that you can work specifically with a given part of GitHub API. If you want to only work with activity starring API do the following: ```ruby starring = Github::Client::Activity::Starring.new oauth_token: token starring.star 'piotrmurach', 'github' ``` Please refer to the [documentation](http://rubydoc.info/github/piotrmurach/github/master/frames) and look under `Github::Client` to see all available classes. ### 1.3 Arguments The **github_api** library allows for flexible argument parsing. Arguments can be passed directly inside the method called. The `required` arguments are passed in first, followed by optional parameters supplied as hash options: ```ruby issues = Github::Client::Issues.new issues.milestones.list 'piotrmurach', 'github', state: 'open' ``` In the previous example, the order of arguments is important. However, each method also allows you to specify `required` arguments using hash symbols and thus remove the need for ordering. Therefore, the same example could be rewritten like so: ```ruby issues = Github::Client::Issues.new issues.milestones.list user: 'piotrmurach', repo: 'github', state: 'open' ``` Furthermore, `required` arguments can be passed during instance creation: ```ruby issues = Github::Client::Issues.new user: 'piotrmurach', repo: 'github' issues.milestones.list state: 'open' ``` Similarly, the `required` arguments for the request can be passed inside the current scope such as: ```ruby issues = Github::Client::Issues.new issues.milestones(user: 'piotrmurach', repo: 'github').list state: 'open' ``` But why limit ourselves? You can mix and match arguments, for example: ```ruby issues = Github::Client::Issues.new user: 'piotrmurach' issues.milestones(repo: 'github').list issues.milestones(repo: 'tty').list ``` You can also use a bit of syntactic sugar whereby "username/repository" can be passed as well: ```ruby issues = Github::Client::Issues.new issues.milestones('piotrmurach/github').list issues.milestones.list 'piotrmurach/github' ``` Finally, use the `with` scope to clearly denote your requests ```ruby issues = Github::Client::Issues.new issues.milestones.with(user: 'piotrmurach', repo: 'github').list ``` Please consult the method [documentation](http://rubydoc.info/github/piotrmurach/github/master/frames) or [GitHub specification](https://developer.github.com/v3/) to see which arguments are required and what are the option parameters. ### 1.4 Response Querying The response is of type `Github::ResponseWrapper` and allows traversing all the json response attributes like method calls. In addition, if the response returns more than one resource, these will be automatically yielded to the provided block one by one. For example, when request is issued to list all the branches on a given repository, each branch will be yielded one by one: ```ruby repos = Github::Client::Repos.new repos.branches user: 'piotrmurach', repo: 'github' do |branch| puts branch.name end ``` #### 1.4.1 Response Body The `ResponseWrapper` allows you to call json attributes directly as method calls. there is no magic here, all calls are delegated to the response body. Therefore, you can directly inspect request body by calling `body` method on the `ResponseWrapper` like so: ```ruby response = repos.branches user: 'piotrmurach', repo: 'github' response.body # => Array of branches ``` #### 1.4.2 Response Headers Each response comes packaged with methods allowing for inspection of HTTP start line and headers. For example, to check for rate limits and status codes do: ```ruby response = Github::Client::Repos.branches 'piotrmurach', 'github' response.headers.ratelimit_limit # "5000" response.headers.ratelimit_remaining # "4999" response.headers.status # "200" response.headers.content_type # "application/json; charset=utf-8" response.headers.etag # "\"2c5dfc54b3fe498779ef3a9ada9a0af9\"" response.headers.cache_control # "public, max-age=60, s-maxage=60" ``` #### 1.4.3 Response Success If you want to verify if the response was success, namely, that the `200` code was returned call the `success?` like so: ```ruby response = Github::Client::Repos.branches 'piotrmurach', 'github' response.success? # => true ``` ### 1.5 Request Headers It is possible to specify additional header information which will be added to the final request. For example, to set `etag` and `X-Poll_Interval` headers, use the `:headers` hash key inside the `:options` hash like in the following: ```ruby events = Github::Client::Activity::Events.new events.public headers: { 'X-Poll-Interval': 60, 'ETag': "a18c3bded88eb5dbb5c849a489412bf3" } ``` #### 1.5.1 Media Types In order to set custom media types for a request use the accept header. By using the `:accept` key you can determine media type like in the example: ```ruby issues = Github::Client::Issues.new issues.get 'piotrmurach', 'github', 108, accept: 'application/vnd.github.raw' ``` ## 2 Configuration The **github_api** provides ability to specify global configuration options. These options will be available to all api calls. ### 2.1 Basic The configuration options can be set by using the `configure` helper ```ruby Github.configure do |c| c.basic_auth = "login:password" c.adapter = :typheous c.user = 'piotrmurach' c.repo = 'finite_machine' end ``` Alternatively, you can configure the settings by passing a block to an instance like: ```ruby Github.new do |c| c.endpoint = 'https://github.company.com/api/v3' c.site = 'https://github.company.com' c.upload_endpoint = 'https://github.company.com/api/uploads' end ``` or simply by passing hash of options to an instance like so ```ruby github = Github.new basic_auth: 'login:password', adapter: :typheous, user: 'piotrmurach', repo: 'finite_machine' ``` The following is the full list of available configuration options: ```ruby adapter # Http client used for performing requests. Default :net_http auto_pagination # Automatically traverse requests page links. Default false basic_auth # Basic authentication in form login:password. client_id # Oauth client id. client_secret # Oauth client secret. connection_options # Hash of connection options. endpoint # Enterprise API endpoint. Default: 'https://api.github.com' oauth_token # Oauth authorization token. org # Global organization used in requests if none provided per_page # Number of items per page. Max of 100. Default 30. repo # Global repository used in requests in none provided site # enterprise API web endpoint ssl # SSL settings in hash form. user # Global user used for requests if none provided user_agent # Custom user agent name. Default 'Github API Ruby Gem' ``` ### 2.2 Advanced The **github_api** will use the default middleware stack which is exposed by calling `stack` on a client instance. However, this stack can be freely modified with methods such as `insert`, `insert_after`, `delete` and `swap`. For instance, to add your `CustomMiddleware` do: ```ruby Github.configure do |c| c.stack.insert_after Github::Response::Helpers, CustomMiddleware end ``` Furthermore, you can build your entire custom stack and specify other connection options such as `adapter` by doing: ```ruby Github.new do |c| c.adapter :excon c.stack do |builder| builder.use Github::Response::Helpers builder.use Github::Response::Jsonize end end ``` ### 2.3 SSL By default requests over SSL are set to OpenSSL::SSL::VERIFY_PEER. However, you can turn off peer verification by ```ruby github = Github.new ssl: { verify: false } ``` If your client fails to find CA certs, you can pass other SSL options to specify exactly how the information is sourced ```ruby ssl: { client_cert: "/usr/local/www.example.com/client_cert.pem" client_key: "/user/local/www.example.com/client_key.pem" ca_file: "example.com.cert" ca_path: "/etc/ssl/" } ``` For instance, download CA root certificates from Mozilla [cacert](http://curl.haxx.se/ca/cacert.pem) and point ca_file at your certificate bundle location. This will allow the client to verify the github.com ssl certificate as authentic. ### 2.4 Caching Caching is supported through the [`faraday-http-cache` gem](https://github.com/plataformatec/faraday-http-cache). Add the gem to your Gemfile: ```ruby gem 'faraday-http-cache' ``` You can now configure cache parameters as follows ```ruby Github.configure do |config| config.stack = proc do |builder| builder.use Faraday::HttpCache, store: Rails.cache end end ``` More details on the available options can be found in the gem's own documentation: https://github.com/plataformatec/faraday-http-cache#faraday-http-cache ## 3 Authentication ### 3.1 Basic To start making requests as authenticated user you can use your GitHub username and password like so ```ruby Github.new basic_auth: 'login:password' ``` Though this method is convenient you should strongly consider using `OAuth` for improved security reasons. ### 3.2 Authorizations API #### 3.2.1 For a User To create an access token through the GitHub Authorizations API, you are required to pass your basic credentials and scopes you wish to have for the authentication token. ```ruby github = Github.new basic_auth: 'login:password' github.auth.create scopes: ['repo'], note: 'admin script' ``` You can add more than one scope from the `user`, `public_repo`, `repo`, `gist` or leave the scopes parameter out, in which case, the default read-only access will be assumed (includes public user profile info, public repo info, and gists). #### 3.2.2 For an App Furthermore, to create auth token for an application you need to pass `:app` argument together with `:client_id` and `:client_secret` parameters. ```ruby github = Github.new basic_auth: 'login:password' github.auth.app.create 'client-id', scopes: ['repo'] ``` In order to revoke auth token(s) for an application you must use basic authentication with `client_id` as login and `client_secret` as password. ```ruby github = Github.new basic_auth: "client_id:client_secret" github.auth.app.delete 'client-id' ``` Revoke a specific app token. ```ruby github.auth.app.delete 'client-id', 'access-token' ``` ### 3.3 Scopes You can check OAuth scopes you have by: ```ruby github = Github.new oauth_token: 'token' github.scopes.list # => ['repo'] ``` or inidividually for a given user: ```ruby github = Github.new github.scopes.list 'token' ``` To list the scopes that the particular GitHub API action checks for do: ```ruby repos = Github::Client::Repos.new response = repos.list user: 'piotrmurach' response.headers.accepted_oauth_scopes # => ['delete_repo', 'repo', 'public_repo'] ``` To understand what each scope means refer to [documentation](http://developer.github.com/v3/oauth/#scopes) ### 3.4 Application OAuth In order to authenticate your app through OAuth2 on GitHub you need to * Visit https://github.com/settings/applications/new and register your app. You will need to be logged in to initially register the application. * Authorize your credentials https://github.com/login/oauth/authorize You can use convenience methods to help you achieve this using **GithubAPI** gem: ```ruby github = Github.new client_id: '...', client_secret: '...' github.authorize_url redirect_uri: 'http://localhost', scope: 'repo' # => "https://github.com/login/oauth/authorize?scope=repo&response_type=code&client_id='...'&redirect_uri=http%3A%2F%2Flocalhost" ``` After you get your authorization code, call to receive your access_token ```ruby token = github.get_token( authorization_code ) ``` Once you have your access token, configure your github instance following instructions under Configuration. **Note**: If you are working locally (i.e. your app URL and callback URL are localhost), do not specify a ```:redirect_uri``` otherwise you will get a ```redirect_uri_mismatch``` error. ### 3.5 Two-Factor In order to use [Two-Factor](https://help.github.com/articles/about-two-factor-authentication) authentication you need provide `X-GitHub-OTP: required; :2fa-type` header. You can add headers during initialization: ```ruby Github.new do |config| config.basic_auth = "user:password" config.connection_options = {headers: {"X-GitHub-OTP" => '2fa token'}} end ``` or per request: ```ruby github = Github.new basic_auth: 'login:password' github.oauth.create scopes: ["public_repo"], headers: {"X-GitHub-OTP" => "2fa token"} ``` ## 4 Pagination Any request that returns multiple items will be paginated to 30 items by default. You can specify custom `page` and `per_page` query parameters to alter default behavior. For instance: ```ruby repos = Github::Client::Repos.new response = repos.list user: 'wycats', per_page: 10, page: 5 ``` Then you can query the pagination information included in the link header by: ```ruby response.links.first # Shows the URL of the first page of results. response.links.next # Shows the URL of the immediate next page of results. response.links.prev # Shows the URL of the immediate previous page of results. response.links.last # Shows the URL of the last page of results. ``` In order to iterate through the entire result set page by page, you can use convenience methods: ```ruby response.each_page do |page| page.each do |repo| puts repo.name end end ``` or use `has_next_page?` and `next_page` helper methods like in the following: ```ruby while response.has_next_page? ... process response ... res.next_page end ``` One can also navigate straight to the specific page by: ```ruby res.count_pages # Number of pages res.page 5 # Requests given page if it exists, nil otherwise res.first_page # Get first page res.next_page # Get next page res.prev_page # Get previous page res.last_page # Get last page ``` ### 4.1 Auto pagination You can retrieve all pages in one invocation by passing the `auto_pagination` option like so: ```ruby github = Github.new auto_pagination: true ``` Depending at what stage you pass the `auto_pagination` it will affect all or only a single request. For example, in order to auto paginate all Repository API methods do: ```ruby Github::Сlient::Repos.new auto_pagination: true ``` However, to only auto paginate results for a single request do: ```ruby Github::Client::Repos.new.list user: '...', auto_pagination: true ``` ## 5 Error Handling The generic error class `Github::Error::GithubError` will handle both the client (`Github::Error::ClientError`) and service (`Github::Error::ServiceError`) side errors. For instance in your code you can catch errors like ```ruby begin # Do something with github_api gem rescue Github::Error::GithubError => e puts e.message if e.is_a? Github::Error::ServiceError # handle GitHub service errors such as 404 elsif e.is_a? Github::Error::ClientError # handle client errors e.i. missing required parameter in request end end ``` ### 5.1 Client Error Any time **Github** client has a problem sending request a `Github::Error::ClientError` is raised that will provide a summary of the problem and possible solutions. ### 5.2 Service Error When the **Github** client receives a HTTP response from GitHub service that indicates error then `Github::Error::ServiceError` is raised. There are number of specific error types such as `Github::Error::NotAcceptable` when `406` status code is returned. #### 5.2.1 Data When `Github::Error::ServiceError` is raised you can call `data` to access it payload in JSON format. #### 5.2.2 Error messages Anytime there are error messages provided with `Github::Error::ServiceError` you can access them by calling `error_messages` helper. ## 6 Examples ### 6.1 Rails A Rails controller that allows a user to authorize their GitHub account and then performs a request. ```ruby class GithubController < ApplicationController def authorize address = github.authorize_url redirect_uri: 'http://...', scope: 'repo' redirect_to address end def callback authorization_code = params[:code] access_token = github.get_token authorization_code access_token.token # => returns token value end private def github @github ||= Github.new client_id: '...', client_secret: '...' end end ``` ### 6.2 Manipulating Files In order to be able to create/update/remove files you need to use Contents API like so: ```ruby contents = Github::Client::Repos::Contents.new oauth_token: '...' ``` Having instantiated the contents, to create a file do: ```ruby contents.create 'username', 'repo_name', 'full_path_to/file.ext', path: 'full_path_to/file.ext', message: 'Your commit message', content: 'The contents of your file' ``` Content is all Base64 encoded to/from the API, and when you create a file it encodes it automatically for you. To update a file, first you need to find the file so you can get the SHA you're updating off of: ```ruby file = contents.find path: 'full_path_to/file.ext' ``` Then update the file just like you do with creating: ```ruby contents.update 'username', 'repo_name', 'full_path_to/file.ext', path: 'full_path_to/file.ext' message: 'Your commit message', content: 'The contents to be updated', sha: file.sha ``` Finally to remove a file, find the file so you can get the SHA you're removing: ```ruby file = contents.find path: 'full_path_to/file.ext' ``` Then delete the file like so: ```ruby github.delete 'username', 'tome-of-knowledge', 'full_path_to/file.ext', path: 'full_path_to/file.ext', message: 'Your Commit Message', sha: file.sha ``` ## 7 Testing The test suite is split into two groups, `live` and `mock`. The `live` tests are in the `features` folder and exercise the GitHub API directly by making live requests and then caching responses with VCR in directory named `features\cassettes`. For details on how to get set up, please navigate to the `features` folder. To run all feature tests do: ```ruby bundle exec rake features ``` The `mock` tests are in the `spec` folder and their primary concern is to test the gem internals without the hindrance of external calls. To run all specs do: ```ruby bundle exec rake spec ``` Finally to run all tests do: ```ruby bundle exec rake ``` ## Development Questions or problems? Please post them on the [issue tracker](https://github.com/piotrmurach/github/issues). You can contribute changes by forking the project and submitting a pull request. You can ensure the tests are passing by running `bundle` and `rake`. ## Contributing Bug reports and pull requests are welcome on GitHub at https://github.com/piotrmurach/github. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct. ## Copyright Copyright (c) 2011-2017 Piotr Murach. See LICENSE.txt for further details.