pib-client-cached 0.22.0

API client for pib-service - caching data storage
Documentation
// SPDX-FileCopyrightText: Politik im Blick developers
// SPDX-FileCopyrightText: Wolfgang Silbermayr <wolfgang@silbermayr.at>
//
// SPDX-License-Identifier: AGPL-3.0-or-later OR EUPL-1.2

use async_trait::async_trait;
use log::info;
use pib_client::PibClient;
use pib_service_api_types::{
    Pagination,
    body::{Body, UpdateBody},
};
use pib_service_core_types::{BodyId, BodyIdOrAlias, DataItem, DataPage};

use crate::item::{
    AliasGetableItem, AliasUpdatableItem, CreateableItem, GetableItem, PageableItem, UpdatableItem,
};

#[async_trait(?Send)]
impl GetableItem<(), BodyId, Body> for Body {
    async fn get<C: PibClient>(
        client: &C,
        (): (),
        body_id: BodyId,
    ) -> Result<DataItem<(), BodyId, Body>, C::ClientError> {
        Ok(client.body_by_id_or_alias_get(body_id.into()).await?)
    }
}

#[async_trait(?Send)]
impl AliasGetableItem<(), BodyId, Body, BodyIdOrAlias> for Body {
    async fn get_by_alias<C: PibClient>(
        client: &C,
        (): (),
        body_id_or_alias: BodyIdOrAlias,
    ) -> Result<DataItem<(), BodyId, Body>, C::ClientError> {
        Ok(client.body_by_id_or_alias_get(body_id_or_alias).await?)
    }

    fn get_aliases(item: &DataItem<(), BodyId, Body>) -> Vec<BodyIdOrAlias> {
        let id = item.id.into();
        if let Some(alias) = item.value.alias.clone() {
            vec![id, alias.clone().into()]
        } else {
            vec![id]
        }
    }
}

#[async_trait(?Send)]
impl PageableItem<(), BodyId, Body> for Body {
    async fn get_page<C: PibClient>(
        client: &C,
        _page_id: (),
        pagination: Pagination,
    ) -> Result<DataPage<(), BodyId, Body>, C::ClientError> {
        Ok(client.body_get(pagination).await?)
    }
}

#[async_trait(?Send)]
impl CreateableItem<(), BodyId, Body> for Body {
    async fn create<C: PibClient>(
        client: &C,
        _parent_id: (),
        body: Body,
    ) -> Result<DataItem<(), BodyId, Body>, C::ClientError> {
        let created_item = client.body_post(body).await?;
        info!("Created a new body: {created_item:?}");
        Ok(created_item)
    }
}

#[async_trait(?Send)]
impl UpdatableItem<(), BodyId, Body, UpdateBody> for Body {
    async fn update<C: PibClient>(
        client: &C,
        (): (),
        body_id: BodyId,
        update_item: UpdateBody,
    ) -> Result<DataItem<(), BodyId, Body>, C::ClientError> {
        let updated_item = client
            .body_by_id_or_alias_patch(body_id.into(), update_item)
            .await?;
        info!("Updated body: {updated_item:?}");
        Ok(updated_item)
    }
}

#[async_trait(?Send)]
impl AliasUpdatableItem<(), BodyId, Body, UpdateBody, BodyIdOrAlias> for Body {
    async fn update_by_alias<C: PibClient>(
        client: &C,
        (): (),
        body_id_or_alias: BodyIdOrAlias,
        update_item: UpdateBody,
    ) -> Result<DataItem<(), BodyId, Body>, C::ClientError> {
        let updated_item = client
            .body_by_id_or_alias_patch(body_id_or_alias, update_item)
            .await?;
        info!("Updated body: {updated_item:?}");
        Ok(updated_item)
    }
}