Struct mastodon_async::registration::Registration

pub struct Registration<'a> { /* private fields */ }

Handles registering your mastodon app to your instance. It is recommended you cache your data struct to avoid registering on every run.

Implementations

impl<'a> Registration<'a>

pub fn new<I: Into<String>>(base: I) -> Self

Construct a new registration process to the instance of the base url.

use mastodon_async::prelude::*;

let registration = Registration::new("https://botsin.space");

pub fn new_with_client<I: Into<String>>(base: I, client: Client) -> Self

Construct a new registration process to the instance of the base url, using the provided Client.

use mastodon_async::prelude::*;

let client = reqwest::Client::builder().user_agent("my cool app").build().unwrap();
let registration = Registration::new_with_client("https://botsin.space", client);

impl<'a> Registration<'a>

pub fn client_name<I: Into<Cow<'a, str>>>(&mut self, name: I) -> &mut Self

Sets the name of this app

This is required, and if this isn’t set then the AppBuilder::build method will fail

pub fn redirect_uris<I: Into<Cow<'a, str>>>(&mut self, uris: I) -> &mut Self

Sets the redirect uris that this app uses

pub fn scopes(&mut self, scopes: Scopes) -> &mut Self

Sets the scopes that this app requires

The default for an app is Scopes::Read

pub fn website<I: Into<Cow<'a, str>>>(&mut self, website: I) -> &mut Self

Sets the optional “website” to register the app with

pub fn force_login(&mut self, force_login: bool) -> &mut Self

Forces the user to re-login (useful if you need to re-auth as a different user on the same instance

pub async fn register<I: TryInto<App>>(&mut self, app: I) -> Result<Registered>

where Error: From<<I as TryInto<App>>::Error>,

Register the given application

use mastodon_async::{apps::App, prelude::*};

tokio_test::block_on(async {
    let mut app = App::builder();
    app.client_name("mastodon-async_test");

    let registration = Registration::new("https://botsin.space")
        .register(app)
        .await
        .unwrap();
    let url = registration.authorize_url().unwrap();
    // Here you now need to open the url in the browser
    // And handle a the redirect url coming back with the code.
    let code = String::from("RETURNED_FROM_BROWSER");
    let mastodon = registration.complete(&code).await.unwrap();

    println!("{:?}", mastodon.get_home_timeline().await.unwrap().initial_items);
});

pub async fn build(&mut self) -> Result<Registered>

Register the application with the server from the base url.

use mastodon_async::prelude::*;

tokio_test::block_on(async {
    let registration = Registration::new("https://botsin.space")
        .client_name("mastodon-async_test")
        .build()
        .await
        .unwrap();
    let url = registration.authorize_url().unwrap();
    // Here you now need to open the url in the browser
    // And handle a the redirect url coming back with the code.
    let code = String::from("RETURNED_FROM_BROWSER");
    let mastodon = registration.complete(&code).await.unwrap();

    println!("{:?}", mastodon.get_home_timeline().await.unwrap().initial_items);
});

Trait Implementations

impl<'a> Clone for Registration<'a>

fn clone(&self) -> Registration<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Registration<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.