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::by_id_or_alias::{
        membership::{
            Membership, MembershipParentId, OrganizationMembershipParentId,
            PersonMembershipParentId, UpdateMembership,
        },
        organization, person,
    },
};
use pib_service_core_types::{DataItem, DataPage, MembershipId};

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

#[async_trait(?Send)]
impl GetableItem<MembershipParentId, MembershipId, Membership> for Membership {
    async fn get<C: PibClient>(
        client: &C,
        MembershipParentId { body_id }: MembershipParentId,
        membership_id: MembershipId,
    ) -> Result<DataItem<MembershipParentId, MembershipId, Membership>, C::ClientError> {
        Ok(client
            .body_by_id_or_alias_membership_by_id_get(body_id, membership_id)
            .await?)
    }
}

#[async_trait(?Send)]
impl GetableItem<PersonMembershipParentId, MembershipId, Membership> for Membership {
    async fn get<C: PibClient>(
        client: &C,
        PersonMembershipParentId { body_id, person_id }: PersonMembershipParentId,
        membership_id: MembershipId,
    ) -> Result<DataItem<PersonMembershipParentId, MembershipId, Membership>, C::ClientError> {
        Ok(client
            .body_by_id_or_alias_person_by_id_membership_by_id_get(
                body_id,
                person_id,
                membership_id,
            )
            .await?)
    }
}

#[async_trait(?Send)]
impl GetableItem<OrganizationMembershipParentId, MembershipId, Membership> for Membership {
    async fn get<C: PibClient>(
        client: &C,
        OrganizationMembershipParentId {
            body_id,
            organization_id,
        }: OrganizationMembershipParentId,
        membership_id: MembershipId,
    ) -> Result<DataItem<OrganizationMembershipParentId, MembershipId, Membership>, C::ClientError>
    {
        Ok(client
            .body_by_id_or_alias_organization_by_id_membership_by_id_get(
                body_id,
                organization_id,
                membership_id,
            )
            .await?)
    }
}

#[async_trait(?Send)]
impl PageableItem<MembershipParentId, MembershipId, Membership> for Membership {
    async fn get_page<C: PibClient>(
        client: &C,
        MembershipParentId { body_id }: MembershipParentId,
        pagination: Pagination,
    ) -> Result<DataPage<MembershipParentId, MembershipId, Membership>, C::ClientError> {
        Ok(client
            .body_by_id_or_alias_membership_get(body_id, pagination)
            .await?)
    }
}

#[async_trait(?Send)]
impl PageableItem<PersonMembershipParentId, MembershipId, Membership> for Membership {
    async fn get_page<C: PibClient>(
        client: &C,
        PersonMembershipParentId { body_id, person_id }: PersonMembershipParentId,
        pagination: Pagination,
    ) -> Result<DataPage<PersonMembershipParentId, MembershipId, Membership>, C::ClientError> {
        Ok(client
            .body_by_id_or_alias_person_by_id_membership_get(body_id, person_id, pagination)
            .await?)
    }
}

#[async_trait(?Send)]
impl PageableItem<OrganizationMembershipParentId, MembershipId, Membership> for Membership {
    async fn get_page<C: PibClient>(
        client: &C,
        OrganizationMembershipParentId {
            body_id,
            organization_id,
        }: OrganizationMembershipParentId,
        pagination: Pagination,
    ) -> Result<DataPage<OrganizationMembershipParentId, MembershipId, Membership>, C::ClientError>
    {
        Ok(client
            .body_by_id_or_alias_organization_by_id_membership_get(
                body_id,
                organization_id,
                pagination,
            )
            .await?)
    }
}

#[async_trait(?Send)]
impl CreateableItem<MembershipParentId, MembershipId, Membership> for Membership {
    async fn create<C: PibClient>(
        client: &C,
        MembershipParentId { body_id }: MembershipParentId,
        membership: Membership,
    ) -> Result<DataItem<MembershipParentId, MembershipId, Membership>, C::ClientError> {
        let created_item = client
            .body_by_id_or_alias_membership_post(body_id, membership)
            .await?;
        info!("Created a new membership: {created_item:?}");
        Ok(created_item)
    }
}

#[async_trait(?Send)]
impl
    CreateableItem<
        MembershipParentId,
        MembershipId,
        Membership,
        OrganizationMembershipParentId,
        organization::by_id::membership::NewMembership,
    > for Membership
{
    async fn create<C: PibClient>(
        client: &C,
        OrganizationMembershipParentId {
            body_id,
            organization_id,
        }: OrganizationMembershipParentId,
        new_item: organization::by_id::membership::NewMembership,
    ) -> Result<DataItem<OrganizationMembershipParentId, MembershipId, Membership>, C::ClientError>
    {
        let created_item = client
            .body_by_id_or_alias_organization_by_id_membership_post(
                body_id,
                organization_id,
                new_item,
            )
            .await?;
        info!("Created a new membership: {created_item:?}");
        Ok(created_item)
    }
}

#[async_trait(?Send)]
impl
    CreateableItem<
        MembershipParentId,
        MembershipId,
        Membership,
        PersonMembershipParentId,
        person::by_id::membership::NewMembership,
    > for Membership
{
    async fn create<C: PibClient>(
        client: &C,
        PersonMembershipParentId { body_id, person_id }: PersonMembershipParentId,
        new_item: person::by_id::membership::NewMembership,
    ) -> Result<DataItem<PersonMembershipParentId, MembershipId, Membership>, C::ClientError> {
        let created_item = client
            .body_by_id_or_alias_person_by_id_membership_post(body_id, person_id, new_item)
            .await?;
        info!("Created a new membership: {created_item:?}");
        Ok(created_item)
    }
}

#[async_trait(?Send)]
impl UpdatableItem<MembershipParentId, MembershipId, Membership, UpdateMembership> for Membership {
    async fn update<C: PibClient>(
        client: &C,
        MembershipParentId { body_id }: MembershipParentId,
        membership_id: MembershipId,
        update_item: UpdateMembership,
    ) -> Result<DataItem<MembershipParentId, MembershipId, Membership>, C::ClientError> {
        let updated_item = client
            .body_by_id_or_alias_membership_by_id_patch(body_id, membership_id, update_item)
            .await?;
        info!("Updated membership: {updated_item:?}");
        Ok(updated_item)
    }
}