gitabu 0.1.0

data/lib/gitabu/api/v3/scim.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+# INFO ON GENERATED CODE
+#
+# This file is generated.
+# See the contribution guide on how to improve the code.
+#
+# INFO ON GENERATED CODE
+
+# Ruby gem that helps you work with Github API.
+module Gitabu
+  # API module
+  module Api
+    # Github Version 3
+    module V3
+      # Class to display Scim result
+      class ScimResult
+        attr_accessor :result, :message
+
+        def initialize(result:, message:)
+          @result = result
+          @message = message
+        end
+      end
+
+      # Class to display error result
+      class ScimErrorResult
+        attr_accessor :result, :message
+
+        def initialize(result:, message:)
+          @result = result
+          @message = message
+        end
+      end
+
+      # Scim endpoints.
+      class Scim
+        def self.list_scim_provisioned_identities(org: nil, options: nil)
+          new.list_scim_provisioned_identities(org, options)
+        end
+
+        def self.provision_and_invite_a_scim_user(org: nil, username: nil, displayname: nil, name: nil, emails: nil, schemas: nil, externalid: nil, groups: nil, active: nil, options: nil)
+          new.provision_and_invite_a_scim_user(org, username, displayname, name, emails, schemas, externalid, groups, active, options)
+        end
+
+        def self.get_scim_provisioning_information_for_a_user(org: nil, scim_user_id: nil, options: nil)
+          new.get_scim_provisioning_information_for_a_user(org, scim_user_id, options)
+        end
+
+        def self.update_a_provisioned_organization_membership(org: nil, scim_user_id: nil, schemas: nil, displayname: nil, externalid: nil, groups: nil, active: nil, username: nil, name: nil, emails: nil, options: nil)
+          new.update_a_provisioned_organization_membership(org, scim_user_id, schemas, displayname, externalid, groups, active, username, name, emails, options)
+        end
+
+        def self.update_an_attribute_for_a_scim_user(org: nil, scim_user_id: nil, schemas: nil, operations: nil, options: nil)
+          new.update_an_attribute_for_a_scim_user(org, scim_user_id, schemas, operations, options)
+        end
+
+        def self.delete_a_scim_user_from_an_organization(org: nil, scim_user_id: nil, options: nil)
+          new.delete_a_scim_user_from_an_organization(org, scim_user_id, options)
+        end
+
+        private
+
+        # list scim provisioned identities
+        #
+        # @param org [String]
+        #
+        # @return ScimResult, ScimErrorResult
+        def list_scim_provisioned_identities(org, options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { startIndex: options[:startIndex], count: options[:count], filter: options[:filter] }
+          uri     = "#{Gitabu::BASE_URL}/scim/v2/organizations/#{org}/Users"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            ScimResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            ScimErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # provision and invite a scim user
+        #
+        # @param org [String]
+        # @param username [String] Required. Configured by the admin. Could be an email, login, or username
+        # @param displayname [String] The name of the user, suitable for display to end-users
+        # @param name [Object] Required.
+        # @param emails [Array of objects] Required. user emails
+        # @param schemas [Array of strings]
+        # @param externalid [String]
+        # @param groups [Array of strings]
+        # @param active [Boolean]
+        #
+        # @return ScimResult, ScimErrorResult
+        def provision_and_invite_a_scim_user(org, username, displayname, name, emails, schemas, externalid, groups, active, _options)
+          auth    = nil
+          body    = { username: username, displayname: displayname, name: name, emails: emails, schemas: schemas, externalid: externalid, groups: groups, active: active }
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = nil
+          uri     = "#{Gitabu::BASE_URL}/scim/v2/organizations/#{org}/Users"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :post, params: params, uri: uri)
+
+          if http_call.successful?
+            ScimResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            ScimErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # get scim provisioning information for a user
+        #
+        # @param org [String]
+        # @param scim_user_id [String] scim_user_id parameter
+        #
+        # @return ScimResult, ScimErrorResult
+        def get_scim_provisioning_information_for_a_user(org, scim_user_id, _options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = nil
+          uri     = "#{Gitabu::BASE_URL}/scim/v2/organizations/#{org}/Users/#{scim_user_id}"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            ScimResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            ScimErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # update a provisioned organization membership
+        #
+        # @param org [String]
+        # @param scim_user_id [String] scim_user_id parameter
+        # @param schemas [Array of strings]
+        # @param displayname [String] The name of the user, suitable for display to end-users
+        # @param externalid [String]
+        # @param groups [Array of strings]
+        # @param active [Boolean]
+        # @param username [String] Required. Configured by the admin. Could be an email, login, or username
+        # @param name [Object] Required.
+        # @param emails [Array of objects] Required. user emails
+        #
+        # @return ScimResult, ScimErrorResult
+        def update_a_provisioned_organization_membership(org, scim_user_id, schemas, displayname, externalid, groups, active, username, name, emails, _options)
+          auth    = nil
+          body    = { schemas: schemas, displayname: displayname, externalid: externalid, groups: groups, active: active, username: username, name: name, emails: emails }
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = nil
+          uri     = "#{Gitabu::BASE_URL}/scim/v2/organizations/#{org}/Users/#{scim_user_id}"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :put, params: params, uri: uri)
+
+          if http_call.successful?
+            ScimResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            ScimErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # update an attribute for a scim user
+        #
+        # @param org [String]
+        # @param scim_user_id [String] scim_user_id parameter
+        # @param schemas [Array of strings]
+        # @param operations [Array of objects] Required. Set of operations to be performed
+        #
+        # @return ScimResult, ScimErrorResult
+        def update_an_attribute_for_a_scim_user(org, scim_user_id, schemas, operations, _options)
+          auth    = nil
+          body    = { schemas: schemas, operations: operations }
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = nil
+          uri     = "#{Gitabu::BASE_URL}/scim/v2/organizations/#{org}/Users/#{scim_user_id}"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :patch, params: params, uri: uri)
+
+          if http_call.successful?
+            ScimResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            ScimErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # delete a scim user from an organization
+        #
+        # @param org [String]
+        # @param scim_user_id [String] scim_user_id parameter
+        #
+        # @return ScimResult, ScimErrorResult
+        def delete_a_scim_user_from_an_organization(org, scim_user_id, _options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = nil
+          uri     = "#{Gitabu::BASE_URL}/scim/v2/organizations/#{org}/Users/#{scim_user_id}"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :delete, params: params, uri: uri)
+
+          if http_call.successful?
+            ScimResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            ScimErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitabu/api/v3/search.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+# INFO ON GENERATED CODE
+#
+# This file is generated.
+# See the contribution guide on how to improve the code.
+#
+# INFO ON GENERATED CODE
+
+# Ruby gem that helps you work with Github API.
+module Gitabu
+  # API module
+  module Api
+    # Github Version 3
+    module V3
+      # Class to display Search result
+      class SearchResult
+        attr_accessor :result, :message
+
+        def initialize(result:, message:)
+          @result = result
+          @message = message
+        end
+      end
+
+      # Class to display error result
+      class SearchErrorResult
+        attr_accessor :result, :message
+
+        def initialize(result:, message:)
+          @result = result
+          @message = message
+        end
+      end
+
+      # Search endpoints.
+      class Search
+        def self.search_code(options: nil)
+          new.search_code(options)
+        end
+
+        def self.search_commits(options: nil)
+          new.search_commits(options)
+        end
+
+        def self.search_issues_and_pull_requests(options: nil)
+          new.search_issues_and_pull_requests(options)
+        end
+
+        def self.search_labels(options: nil)
+          new.search_labels(options)
+        end
+
+        def self.search_repositories(options: nil)
+          new.search_repositories(options)
+        end
+
+        def self.search_topics(options: nil)
+          new.search_topics(options)
+        end
+
+        def self.search_users(options: nil)
+          new.search_users(options)
+        end
+
+        private
+
+        # search code
+        #
+        # @params options [Hash]
+        #
+        # @return SearchResult, SearchErrorResult
+        def search_code(options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { q: options[:q], sort: options[:sort], order: options[:order], per_page: options[:per_page], page: options[:page] }
+          uri     = "#{Gitabu::BASE_URL}/search/code"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SearchResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SearchErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # search commits
+        #
+        # @params options [Hash]
+        #
+        # @return SearchResult, SearchErrorResult
+        def search_commits(options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { q: options[:q], sort: options[:sort], order: options[:order], per_page: options[:per_page], page: options[:page] }
+          uri     = "#{Gitabu::BASE_URL}/search/commits"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SearchResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SearchErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # search issues and pull requests
+        #
+        # @params options [Hash]
+        #
+        # @return SearchResult, SearchErrorResult
+        def search_issues_and_pull_requests(options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { q: options[:q], sort: options[:sort], order: options[:order], per_page: options[:per_page], page: options[:page] }
+          uri     = "#{Gitabu::BASE_URL}/search/issues"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SearchResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SearchErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # search labels
+        #
+        # @params options [Hash]
+        #
+        # @return SearchResult, SearchErrorResult
+        def search_labels(options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { repository_id: options[:repository_id], q: options[:q], sort: options[:sort], order: options[:order], per_page: options[:per_page], page: options[:page] }
+          uri     = "#{Gitabu::BASE_URL}/search/labels"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SearchResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SearchErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # search repositories
+        #
+        # @params options [Hash]
+        #
+        # @return SearchResult, SearchErrorResult
+        def search_repositories(options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { q: options[:q], sort: options[:sort], order: options[:order], per_page: options[:per_page], page: options[:page] }
+          uri     = "#{Gitabu::BASE_URL}/search/repositories"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SearchResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SearchErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # search topics
+        #
+        # @params options [Hash]
+        #
+        # @return SearchResult, SearchErrorResult
+        def search_topics(options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { q: options[:q], per_page: options[:per_page], page: options[:page] }
+          uri     = "#{Gitabu::BASE_URL}/search/topics"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SearchResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SearchErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # search users
+        #
+        # @params options [Hash]
+        #
+        # @return SearchResult, SearchErrorResult
+        def search_users(options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { q: options[:q], sort: options[:sort], order: options[:order], per_page: options[:per_page], page: options[:page] }
+          uri     = "#{Gitabu::BASE_URL}/search/users"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SearchResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SearchErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitabu/api/v3/secret_scanning.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+# INFO ON GENERATED CODE
+#
+# This file is generated.
+# See the contribution guide on how to improve the code.
+#
+# INFO ON GENERATED CODE
+
+# Ruby gem that helps you work with Github API.
+module Gitabu
+  # API module
+  module Api
+    # Github Version 3
+    module V3
+      # Class to display Secret scanning result
+      class SecretScanningResult
+        attr_accessor :result, :message
+
+        def initialize(result:, message:)
+          @result = result
+          @message = message
+        end
+      end
+
+      # Class to display error result
+      class SecretScanningErrorResult
+        attr_accessor :result, :message
+
+        def initialize(result:, message:)
+          @result = result
+          @message = message
+        end
+      end
+
+      # Secret scanning endpoints.
+      class SecretScanning
+        def self.list_secret_scanning_alerts_for_an_enterprise(enterprise: nil, options: nil)
+          new.list_secret_scanning_alerts_for_an_enterprise(enterprise, options)
+        end
+
+        def self.list_secret_scanning_alerts_for_an_organization(org: nil, options: nil)
+          new.list_secret_scanning_alerts_for_an_organization(org, options)
+        end
+
+        def self.list_secret_scanning_alerts_for_a_repository(owner: nil, repo: nil, options: nil)
+          new.list_secret_scanning_alerts_for_a_repository(owner, repo, options)
+        end
+
+        def self.get_a_secret_scanning_alert(owner: nil, repo: nil, alert_number: nil, options: nil)
+          new.get_a_secret_scanning_alert(owner, repo, alert_number, options)
+        end
+
+        def self.update_a_secret_scanning_alert(owner: nil, repo: nil, alert_number: nil, state: nil, resolution: nil, options: nil)
+          new.update_a_secret_scanning_alert(owner, repo, alert_number, state, resolution, options)
+        end
+
+        def self.list_locations_for_a_secret_scanning_alert(owner: nil, repo: nil, alert_number: nil, options: nil)
+          new.list_locations_for_a_secret_scanning_alert(owner, repo, alert_number, options)
+        end
+
+        private
+
+        # list secret scanning alerts for an enterprise
+        #
+        # @param enterprise [String] The slug version of the enterprise name. You can also substitute this value with the enterprise id.
+        #
+        # @return SecretScanningResult, SecretScanningErrorResult
+        def list_secret_scanning_alerts_for_an_enterprise(enterprise, options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { state: options[:state], secret_type: options[:secret_type], resolution: options[:resolution], per_page: options[:per_page], before: options[:before], after: options[:after] }
+          uri     = "#{Gitabu::BASE_URL}/enterprises/#{enterprise}/secret-scanning/alerts"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SecretScanningResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SecretScanningErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # list secret scanning alerts for an organization
+        #
+        # @param org [String]
+        #
+        # @return SecretScanningResult, SecretScanningErrorResult
+        def list_secret_scanning_alerts_for_an_organization(org, options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { state: options[:state], secret_type: options[:secret_type], resolution: options[:resolution], page: options[:page], per_page: options[:per_page] }
+          uri     = "#{Gitabu::BASE_URL}/orgs/#{org}/secret-scanning/alerts"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SecretScanningResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SecretScanningErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # list secret scanning alerts for a repository
+        #
+        # @param owner [String]
+        # @param repo [String]
+        #
+        # @return SecretScanningResult, SecretScanningErrorResult
+        def list_secret_scanning_alerts_for_a_repository(owner, repo, options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { state: options[:state], secret_type: options[:secret_type], resolution: options[:resolution], page: options[:page], per_page: options[:per_page] }
+          uri     = "#{Gitabu::BASE_URL}/repos/#{owner}/#{repo}/secret-scanning/alerts"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SecretScanningResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SecretScanningErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # get a secret scanning alert
+        #
+        # @param owner [String]
+        # @param repo [String]
+        # @param alert_number [Integer] The number that identifies an alert. You can find this at the end of the URL for a code scanning alert within GitHub, and in the number field in the response from the GET /repos/{owner}/{repo}/code-scanning/alerts operation.
+        #
+        # @return SecretScanningResult, SecretScanningErrorResult
+        def get_a_secret_scanning_alert(owner, repo, alert_number, _options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = nil
+          uri     = "#{Gitabu::BASE_URL}/repos/#{owner}/#{repo}/secret-scanning/alerts/#{alert_number}"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SecretScanningResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SecretScanningErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # update a secret scanning alert
+        #
+        # @param owner [String]
+        # @param repo [String]
+        # @param alert_number [Integer] The number that identifies an alert. You can find this at the end of the URL for a code scanning alert within GitHub, and in the number field in the response from the GET /repos/{owner}/{repo}/code-scanning/alerts operation.
+        # @param state [String] Required. Sets the state of the secret scanning alert. Can be either open or resolved. You must provide resolution when you set the state to resolved.
+        # @param resolution [String or null] Required when the state is resolved. The reason for resolving the alert. Can be one of false_positive, wont_fix, revoked, or used_in_tests.
+        #
+        # @return SecretScanningResult, SecretScanningErrorResult
+        def update_a_secret_scanning_alert(owner, repo, alert_number, state, resolution, _options)
+          auth    = nil
+          body    = { state: state, resolution: resolution }
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = nil
+          uri     = "#{Gitabu::BASE_URL}/repos/#{owner}/#{repo}/secret-scanning/alerts/#{alert_number}"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :patch, params: params, uri: uri)
+
+          if http_call.successful?
+            SecretScanningResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SecretScanningErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+
+        # list locations for a secret scanning alert
+        #
+        # @param owner [String]
+        # @param repo [String]
+        # @param alert_number [Integer] The number that identifies an alert. You can find this at the end of the URL for a code scanning alert within GitHub, and in the number field in the response from the GET /repos/{owner}/{repo}/code-scanning/alerts operation.
+        #
+        # @return SecretScanningResult, SecretScanningErrorResult
+        def list_locations_for_a_secret_scanning_alert(owner, repo, alert_number, options)
+          auth    = nil
+          body    = nil
+          headers = { accept: 'application/vnd.github.v3+json' }
+          params  = { page: options[:page], per_page: options[:per_page] }
+          uri     = "#{Gitabu::BASE_URL}/repos/#{owner}/#{repo}/secret-scanning/alerts/#{alert_number}/locations"
+
+          http_call = Gitabu::HttpClient.call(auth: auth, body: body, headers: headers, method: :get, params: params, uri: uri)
+
+          if http_call.successful?
+            SecretScanningResult.new(result: http_call, message: "Successful call to endpoint. #{http_call.result.message}")
+          else
+            SecretScanningErrorResult.new(result: http_call, message: "Failure while calling endpoint. #{http_call.result.message}")
+          end
+        end
+      end
+    end
+  end
+end