Struct GithubClient 

pub struct GithubClient { /* private fields */ }

Implementations

impl GithubClient

pub fn new(token: Option<String>) -> Result<Self, AppError>

pub fn inner(&self) -> &Octocrab

Methods from Deref<Target = Octocrab>

pub async fn authenticate_as_device<I, S>( &self, client_id: &SecretBox<str>, scope: I, ) -> Result<DeviceCodes, Error>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Authenticate with Github’s device flow. This starts the process to obtain a new OAuth.

See https://docs.github.com/en/developers/apps/building-oauth-apps/authorizing-oauth-apps#device-flow for details.

Note: To authenticate against public Github, the Octocrab that calls this method must be constructed with base_uri: "https://github.com" and extra header “ACCEPT: application/json”. For example:

let crab = octocrab::Octocrab::builder()
.base_uri("https://github.com")?
.add_header(ACCEPT, "application/json".to_string())
.build()?;

pub fn installation(&self, id: InstallationId) -> Result<Octocrab, Error>

Returns a new Octocrab based on the current builder but authorizing via a specific installation ID. Typically you will first construct an Octocrab using OctocrabBuilder::app to authenticate as your Github App, then obtain an installation ID, and then pass that here to obtain a new Octocrab with which you can make API calls with the permissions of that installation.

pub async fn installation_and_token( &self, id: InstallationId, ) -> Result<(Octocrab, SecretBox<str>), Error>

Similar to installation, but also eagerly caches the installation token and returns the token. The returned token can be used to make https git requests to e.g. clone repositories that the installation has access to.

See also https://docs.github.com/en/developers/apps/building-github-apps/authenticating-with-github-apps#http-based-git-access-by-an-installation

pub async fn installation_token(&self) -> Result<SecretBox<str>, Error>

Acquire a GitHub App installation access token that does not expire for at least 30 seconds. A cached token will be used if its expiration is far enough in the future. Otherwise, a new token will be acquired and cached.

pub async fn installation_token_with_buffer( &self, buffer: TimeDelta, ) -> Result<SecretBox<str>, Error>

Acquire a GitHub App installation access token that does not expire for at least the duration specified by [buffer]. A cached token will be used if its expiration is far enough in the future. Otherwise, a new token will be acquired and cached.

pub fn user_access_token<S>(&self, token: S) -> Result<Octocrab, Error>

where S: Into<SecretBox<str>>,

Returns a new Octocrab based on the current builder but authorizing via an access token.

See also https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app

pub fn actions(&self) -> ActionsHandler<'_>

Creates a new actions::ActionsHandler for accessing information from GitHub Actions.

pub fn current(&self) -> CurrentAuthHandler<'_>

Creates a current::CurrentAuthHandler that allows you to access information about the current authenticated user.

pub fn activity(&self) -> ActivityHandler<'_>

Creates a activity::ActivityHandler for the current authenticated user.

pub fn apps(&self) -> AppsRequestHandler<'_>

Creates a new apps::AppsRequestHandler for the currently authenticated app.

pub fn gitignore(&self) -> GitignoreHandler<'_>

Creates a gitignore::GitignoreHandler for accessing information about gitignore.

pub fn issues( &self, owner: impl Into<String>, repo: impl Into<String>, ) -> IssueHandler<'_>

Creates a issues::IssueHandler for the repo specified at owner/repo, that allows you to access GitHub’s issues API.

pub fn issues_by_id(&self, id: impl Into<RepositoryId>) -> IssueHandler<'_>

Creates a issues::IssueHandler for the repo specified at repository ID, that allows you to access GitHub’s issues API.

pub fn code_scannings( &self, owner: impl Into<String>, repo: impl Into<String>, ) -> CodeScanningHandler<'_>

Creates a code_scannings::CodeScanningHandler for the repo specified at owner/repo, that allows you to access GitHub’s Code scanning API.

pub fn code_scannings_organisation( &self, owner: impl Into<String>, ) -> CodeScanningHandler<'_>

Creates a code_scannings::CodeScanningHandler for the org specified at owner, that allows you to access GitHub’s Code scanning API.

pub fn commits( &self, owner: impl Into<String>, repo: impl Into<String>, ) -> CommitHandler<'_>

Creates a commits::CommitHandler for the repo specified at owner/repo,

pub fn licenses(&self) -> LicenseHandler<'_>

Creates a licenses::LicenseHandler.

pub fn markdown(&self) -> MarkdownHandler<'_>

Creates a markdown::MarkdownHandler.

pub fn orgs(&self, owner: impl Into<String>) -> OrgHandler<'_>

Creates an orgs::OrgHandler for the specified organization, that allows you to access GitHub’s organization API.

pub fn pulls( &self, owner: impl Into<String>, repo: impl Into<String>, ) -> PullRequestHandler<'_>

Creates a pulls::PullRequestHandler for the repo specified at owner/repo, that allows you to access GitHub’s pull request API.

pub fn repos( &self, owner: impl Into<String>, repo: impl Into<String>, ) -> RepoHandler<'_>

Creates a repos::RepoHandler for the repo specified at owner/repo, that allows you to access GitHub’s repository API.

pub fn repos_by_id(&self, id: impl Into<RepositoryId>) -> RepoHandler<'_>

Creates a repos::RepoHandler for the repo specified at repository ID, that allows you to access GitHub’s repository API.

pub fn projects(&self) -> ProjectHandler<'_>

Creates a projects::ProjectHandler that allows you to access GitHub’s projects API (classic).

pub fn search(&self) -> SearchHandler<'_>

Creates a search::SearchHandler that allows you to construct general queries to GitHub’s API.

pub fn teams(&self, owner: impl Into<String>) -> TeamHandler<'_>

Creates a teams::TeamHandler for the specified organization that allows you to access GitHub’s teams API.

pub fn users(&self, user: impl Into<String>) -> UserHandler<'_>

Creates a users::UserHandler for the specified user using the user name

pub fn users_by_id(&self, user: impl Into<UserId>) -> UserHandler<'_>

Creates a users::UserHandler for the specified user using the user ID

pub fn workflows( &self, owner: impl Into<String>, repo: impl Into<String>, ) -> WorkflowsHandler<'_>

Creates a workflows::WorkflowsHandler for the specified repository that allows you to access GitHub’s workflows API.

pub fn events(&self) -> EventsBuilder<'_>

Creates an events::EventsBuilder that allows you to access GitHub’s events API.

pub fn gists(&self) -> GistsHandler<'_>

Creates a gists::GistsHandler that allows you to access GitHub’s Gists API.

pub fn checks( &self, owner: impl Into<String>, repo: impl Into<String>, ) -> ChecksHandler<'_>

Creates a checks::ChecksHandler that allows to access the Checks API.

pub fn ratelimit(&self) -> RateLimitHandler<'_>

Creates a ratelimit::RateLimitHandler that returns the API rate limit.

pub fn hooks(&self, owner: impl Into<String>) -> HooksHandler<'_>

Creates a hooks::HooksHandler that returns the API hooks

pub fn assignments(&self) -> AssignmentsHandler<'_>

Creates a classroom::AssignmentsHandler providing the GitHub Classroom Assignments API

pub fn classrooms(&self) -> ClassroomHandler<'_>

Creates a classroom::ClassroomHandler providing the GitHub Classroom Classrooms API

pub fn codes_of_conduct(&self) -> CodesOfConductHandler<'_>

Creates a [codes_of_conduct::CodesOfConductHandler] providing the GitHub Codes of Codes of Conduct API

pub async fn graphql<R>( &self, payload: &(impl Serialize + ?Sized), ) -> Result<R, Error>

where R: FromResponse,

Sends a graphql query to GitHub, and deserialises the response from JSON.

let response: serde_json::Value = octocrab::instance()
    .graphql(&serde_json::json!({ "query": "{ viewer { login }}" }))
    .await?;

pub async fn post<P, R>( &self, route: impl AsRef<str>, body: Option<&P>, ) -> Result<R, Error>

where P: Serialize + ?Sized, R: FromResponse,

Send a POST request to route with an optional body, returning the body of the response.

pub async fn _post<P>( &self, uri: impl TryInto<Uri>, body: Option<&P>, ) -> Result<Response<BoxBody<Bytes, Error>>, Error>

where P: Serialize + ?Sized,

Send a POST request with no additional pre/post-processing.

pub async fn get<R, A, P>( &self, route: A, parameters: Option<&P>, ) -> Result<R, Error>

where A: AsRef<str>, P: Serialize + ?Sized, R: FromResponse,

Send a GET request to route with optional query parameters, returning the body of the response.

pub async fn _get( &self, uri: impl TryInto<Uri>, ) -> Result<Response<BoxBody<Bytes, Error>>, Error>

Send a GET request with no additional post-processing.

pub async fn body_to_string( &self, res: Response<BoxBody<Bytes, Error>>, ) -> Result<String, Error>

pub async fn get_with_headers<R, A, P>( &self, route: A, parameters: Option<&P>, headers: Option<HeaderMap>, ) -> Result<R, Error>

where A: AsRef<str>, P: Serialize + ?Sized, R: FromResponse,

Send a GET request to route with optional query parameters and headers, returning the body of the response.

pub async fn _get_with_headers( &self, uri: impl TryInto<Uri>, headers: Option<HeaderMap>, ) -> Result<Response<BoxBody<Bytes, Error>>, Error>

Send a GET request including option to set headers, with no additional post-processing.

pub async fn patch<R, A, B>( &self, route: A, body: Option<&B>, ) -> Result<R, Error>

where A: AsRef<str>, B: Serialize + ?Sized, R: FromResponse,

Send a PATCH request to route with optional query parameters, returning the body of the response.

pub async fn _patch<B>( &self, uri: impl TryInto<Uri>, body: Option<&B>, ) -> Result<Response<BoxBody<Bytes, Error>>, Error>

where B: Serialize + ?Sized,

Send a PATCH request with no additional post-processing.

pub async fn put<R, A, B>(&self, route: A, body: Option<&B>) -> Result<R, Error>

where A: AsRef<str>, B: Serialize + ?Sized, R: FromResponse,

Send a PUT request to route with optional query parameters, returning the body of the response.

pub async fn _put<B>( &self, uri: impl TryInto<Uri>, body: Option<&B>, ) -> Result<Response<BoxBody<Bytes, Error>>, Error>

where B: Serialize + ?Sized,

Send a PUT request with no additional post-processing.

pub fn build_request<B>( &self, builder: Builder, body: Option<&B>, ) -> Result<Request<OctoBody>, Error>

where B: Serialize + ?Sized,

pub async fn delete<R, A, B>( &self, route: A, body: Option<&B>, ) -> Result<R, Error>

where A: AsRef<str>, B: Serialize + ?Sized, R: FromResponse,

Send a DELETE request to route with optional query body, returning the body of the response.

pub async fn _delete<B>( &self, uri: impl TryInto<Uri>, body: Option<&B>, ) -> Result<Response<BoxBody<Bytes, Error>>, Error>

where B: Serialize + ?Sized,

Send a DELETE request with no additional post-processing.

pub async fn send( &self, request: Request<OctoBody>, ) -> Result<Response<BoxBody<Bytes, Error>>, Error>

Send the given request to the underlying service

pub async fn execute( &self, request: Request<impl Into<OctoBody>>, ) -> Result<Response<BoxBody<Bytes, Error>>, Error>

Execute the given request using octocrab’s Client.

pub async fn follow_location_to_data( &self, response: Response<BoxBody<Bytes, Error>>, ) -> Result<Response<BoxBody<Bytes, Error>>, Error>

pub async fn download( &self, uri: impl TryInto<Uri>, content_type: impl TryInto<HeaderValue>, ) -> Result<Vec<u8>, Error>

Download a file from the given URL with the given content type

This is a convenience method that sets the Accept header to the given content type and downloads the file into a Vec<u8>.

pub async fn download_zip( &self, uri: impl TryInto<Uri>, ) -> Result<Vec<u8>, Error>

Download a zip file from the given URL into a Vec<u8>.

pub async fn get_page<R>( &self, uri: &Option<Uri>, ) -> Result<Option<Page<R>>, Error>

where R: DeserializeOwned,

A convenience method to get a page of results (if present).

pub async fn all_pages<R>(&self, page: Page<R>) -> Result<Vec<R>, Error>

where R: DeserializeOwned,

A convenience method to get all the results starting at a given page.

Trait Implementations

impl Deref for GithubClient

type Target = Octocrab

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.