Struct LinkDingClient

pub struct LinkDingClient { /* private fields */ }

A sync client for the LinkDing API.

This client is used to interact with the LinkDing API. It provides methods for managing bookmarks and tags, the full capability of the LinkDing API.

Example

use linkding::{LinkDingClient, LinkDingError, CreateBookmarkBody};

fn main() -> Result<(), LinkDingError> {
    let client = LinkDingClient::new("https://linkding.local:9090", "YOUR_API_TOKEN");
    let new_bookmark = CreateBookmarkBody {
        url: "https://example.com".to_string(),
        ..Default::default()
    };
    let bookmark = client.create_bookmark(new_bookmark)?;
    println!("Bookmark created: {:?}", bookmark);
    client.delete_bookmark(bookmark.id)?;
    println!("Bookmark deleted");
    Ok(())
}

Implementations

impl LinkDingClient

pub fn new(url: &str, token: &str) -> Self

Examples found in repository

examples/upload_asset.rs (line 10)

fn main() {
    let linkding_host =
        std::env::var("LINKDING_HOST").unwrap_or("http://localhost:9090".to_string());
    let linkding_token =
        std::env::var("LINKDING_TOKEN").expect("LINKDING_TOKEN env variable is not set");
    let linkding_client = LinkDingClient::new(&linkding_host, &linkding_token);

    let mut asset_file = std::fs::File::open("examples/asset.txt").unwrap();
    let mut buffer: Vec<u8> = vec![];
    asset_file.read_to_end(&mut buffer).unwrap();

    linkding_client.upload_bookmark_asset(1, &buffer).unwrap();
}

examples/download_asset.rs (line 10)

fn main() {
    let linkding_host =
        std::env::var("LINKDING_HOST").unwrap_or("http://localhost:9090".to_string());
    let linkding_token =
        std::env::var("LINKDING_TOKEN").expect("LINKDING_TOKEN env variable is not set");
    let linkding_client = LinkDingClient::new(&linkding_host, &linkding_token);

    let result = linkding_client
        .download_bookmark_asset(1, 1)
        .expect("Could not download asset");

    let mut asset_file =
        File::create("asset.html").expect("Could not create/overwrite the file asset.html");
    asset_file
        .write(&result)
        .expect("Could not write to asset file");
}

examples/count_bookmarks.rs (line 8)

fn main() {
    let linkding_host =
        std::env::var("LINKDING_HOST").unwrap_or("http://localhost:9090".to_string());
    let linkding_token =
        std::env::var("LINKDING_TOKEN").expect("LINKDING_TOKEN env variable is not set");
    let linkding_client = LinkDingClient::new(&linkding_host, &linkding_token);

    let mut total_bookmarks = 0;
    let mut offset = 0;

    loop {
        let response = linkding_client
            .list_bookmarks(ListBookmarksArgs {
                query: None,
                limit: None,
                offset: Some(offset),
            })
            .expect("Couldn't fetch bookmarks");
        total_bookmarks += response.results.len();
        if response.next.is_none() {
            break;
        }
        offset += 100;
    }

    println!("Total bookmarks: {}", total_bookmarks);
}

pub fn list_bookmarks( &self, args: ListBookmarksArgs, ) -> Result<ListBookmarksResponse, LinkDingError>

List unarchived bookmarks

Examples found in repository

examples/count_bookmarks.rs (lines 15-19)

fn main() {
    let linkding_host =
        std::env::var("LINKDING_HOST").unwrap_or("http://localhost:9090".to_string());
    let linkding_token =
        std::env::var("LINKDING_TOKEN").expect("LINKDING_TOKEN env variable is not set");
    let linkding_client = LinkDingClient::new(&linkding_host, &linkding_token);

    let mut total_bookmarks = 0;
    let mut offset = 0;

    loop {
        let response = linkding_client
            .list_bookmarks(ListBookmarksArgs {
                query: None,
                limit: None,
                offset: Some(offset),
            })
            .expect("Couldn't fetch bookmarks");
        total_bookmarks += response.results.len();
        if response.next.is_none() {
            break;
        }
        offset += 100;
    }

    println!("Total bookmarks: {}", total_bookmarks);
}

pub fn list_archived_bookmarks( &self, args: ListBookmarksArgs, ) -> Result<ListBookmarksResponse, LinkDingError>

List archived bookmarks

pub fn get_bookmark(&self, id: i32) -> Result<Bookmark, LinkDingError>

Get a bookmark by ID

pub fn check_url(&self, url: &str) -> Result<CheckUrlResponse, LinkDingError>

Check if a URL has been bookmarked

If the URL has already been bookmarked this will return the bookmark data, otherwise the bookmark data will be None. The metadata of the webpage will always be returned.

pub fn create_bookmark( &self, body: CreateBookmarkBody, ) -> Result<Bookmark, LinkDingError>

Create a bookmark

If the bookmark already exists, it will be updated with the new data passed in the body parameter.

pub fn update_bookmark( &self, id: i32, body: UpdateBookmarkBody, ) -> Result<Bookmark, LinkDingError>

Update a bookmark

Pass only the fields you want to update in the body parameter.

pub fn archive_bookmark(&self, id: i32) -> Result<bool, LinkDingError>

Archive a bookmark

pub fn unarchive_bookmark(&self, id: i32) -> Result<bool, LinkDingError>

Take a bookmark out of the archive

pub fn delete_bookmark(&self, id: i32) -> Result<bool, LinkDingError>

Delete a bookmark

pub fn list_tags( &self, args: ListTagsArgs, ) -> Result<ListTagsResponse, LinkDingError>

List tags

pub fn get_tag(&self, id: i32) -> Result<TagData, LinkDingError>

Get a tag by ID

pub fn create_tag(&self, name: &str) -> Result<TagData, LinkDingError>

Create a tag

pub fn get_user_profile(&self) -> Result<UserProfile, LinkDingError>

Get the user’s profile

pub fn list_bookmark_assets( &self, id: i32, ) -> Result<ListBookmarkAssetsResponse, LinkDingError>

Lists a bookmarks’ assets

pub fn retrieve_bookmark_asset( &self, bookmark_id: i32, asset_id: i32, ) -> Result<BookmarkAsset, LinkDingError>

Retrieve info for a single asset of a bookmark

pub fn download_bookmark_asset( &self, bookmark_id: i32, asset_id: i32, ) -> Result<Vec<u8>, LinkDingError>

Download a bookmark’s asset

Examples found in repository

examples/download_asset.rs (line 13)

fn main() {
    let linkding_host =
        std::env::var("LINKDING_HOST").unwrap_or("http://localhost:9090".to_string());
    let linkding_token =
        std::env::var("LINKDING_TOKEN").expect("LINKDING_TOKEN env variable is not set");
    let linkding_client = LinkDingClient::new(&linkding_host, &linkding_token);

    let result = linkding_client
        .download_bookmark_asset(1, 1)
        .expect("Could not download asset");

    let mut asset_file =
        File::create("asset.html").expect("Could not create/overwrite the file asset.html");
    asset_file
        .write(&result)
        .expect("Could not write to asset file");
}

pub fn upload_bookmark_asset( &self, bookmark_id: i32, bytes: &[u8], ) -> Result<BookmarkAsset, LinkDingError>

Upload an asset for a bookmark

Examples found in repository

examples/upload_asset.rs (line 16)

fn main() {
    let linkding_host =
        std::env::var("LINKDING_HOST").unwrap_or("http://localhost:9090".to_string());
    let linkding_token =
        std::env::var("LINKDING_TOKEN").expect("LINKDING_TOKEN env variable is not set");
    let linkding_client = LinkDingClient::new(&linkding_host, &linkding_token);

    let mut asset_file = std::fs::File::open("examples/asset.txt").unwrap();
    let mut buffer: Vec<u8> = vec![];
    asset_file.read_to_end(&mut buffer).unwrap();

    linkding_client.upload_bookmark_asset(1, &buffer).unwrap();
}

pub fn delete_bookmark_asset( &self, bookmark_id: i32, asset_id: i32, ) -> Result<bool, LinkDingError>

Delete a bookmark’s asset

Trait Implementations

impl Clone for LinkDingClient

fn clone(&self) -> LinkDingClient

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LinkDingClient

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

Formats the value using the given formatter.