mod alias_cache;
mod item;
mod item_cache;
mod page_index_cache;
use std::rc::Rc;
use cachekit::prelude::CachePolicy;
use item::{CreateableItem, PageableItem};
use pib_client::{IsAuthenticated, PibClient};
use pib_service_api_types::{
Index, Pagination, Search,
body::{
Body, UpdateBody,
by_id_or_alias::{
location::{Location, LocationParentId, UpdateLocation},
meeting::{
EditableMeeting, Meeting, MeetingParentId, UpdateMeeting,
by_id::agenda_item::{
AgendaItem, AgendaItemParentId, UpdateAgendaItem,
by_id::consultation::{Consultation, ConsultationParentId, UpdateConsultation},
},
},
membership::{
Membership, MembershipParentId, OrganizationMembershipParentId,
PersonMembershipParentId, UpdateMembership,
},
organization::{self, Organization, OrganizationParentId, UpdateOrganization},
paper::{Paper, PaperParentId, UpdatePaper},
permission::{NewPermission, Permission, PermissionParentId},
person::{self, Person, PersonParentId, UpdatePerson},
},
},
config::Config,
me::profile::{Profile, UpdateProfile},
user::User,
};
use pib_service_core_types::{
AgendaItemId, BodyId, BodyIdOrAlias, BodyPermissionId, DataItem, DataPage, LocationId,
MeetingId, MembershipId, OrganizationId, PaperId, PersonId, UserId,
};
use tokio::sync::RwLock;
use crate::alias_cache::AliasCache;
use self::{item_cache::ItemCache, page_index_cache::PageIndexCache};
const CACHE_SIZE: usize = 1000;
const CACHE_POLICY: CachePolicy = CachePolicy::Lru;
#[derive(Debug, Clone)]
pub struct CachedClient<C> {
client: C,
data: CachedData,
}
impl<C> CachedClient<C> {
pub fn new(client: C) -> Self {
Self {
client,
data: CachedData::new(),
}
}
}
#[derive(Debug, Clone)]
struct CachedData {
profile: Rc<RwLock<Option<pib_service_api_types::me::profile::Profile>>>,
body_pages: Rc<RwLock<PageIndexCache<(), BodyId, Body>>>,
body_items: Rc<RwLock<ItemCache<(), BodyId, Body>>>,
body_aliases: Rc<RwLock<AliasCache<(), BodyIdOrAlias, BodyId>>>,
user_pages: Rc<RwLock<PageIndexCache<(), UserId, User>>>,
user_items: Rc<RwLock<ItemCache<(), UserId, User>>>,
meeting_pages: Rc<RwLock<PageIndexCache<MeetingParentId, MeetingId, Meeting>>>,
meeting_items: Rc<RwLock<ItemCache<MeetingParentId, MeetingId, Meeting>>>,
agenda_item_pages: Rc<RwLock<PageIndexCache<AgendaItemParentId, AgendaItemId, AgendaItem>>>,
agenda_item_items: Rc<RwLock<ItemCache<AgendaItemParentId, AgendaItemId, AgendaItem>>>,
consultation_items: Rc<RwLock<ItemCache<ConsultationParentId, AgendaItemId, Consultation>>>,
organization_pages:
Rc<RwLock<PageIndexCache<OrganizationParentId, OrganizationId, Organization>>>,
organization_items: Rc<RwLock<ItemCache<OrganizationParentId, OrganizationId, Organization>>>,
person_pages: Rc<RwLock<PageIndexCache<PersonParentId, PersonId, Person>>>,
person_items: Rc<RwLock<ItemCache<PersonParentId, PersonId, Person>>>,
membership_pages: Rc<RwLock<PageIndexCache<MembershipParentId, MembershipId, Membership>>>,
membership_organization_pages:
Rc<RwLock<PageIndexCache<OrganizationMembershipParentId, MembershipId, Membership>>>,
membership_person_pages:
Rc<RwLock<PageIndexCache<PersonMembershipParentId, MembershipId, Membership>>>,
membership_items: Rc<RwLock<ItemCache<MembershipParentId, MembershipId, Membership>>>,
body_permission_pages:
Rc<RwLock<PageIndexCache<PermissionParentId, BodyPermissionId, Permission>>>,
body_permission_items: Rc<RwLock<ItemCache<PermissionParentId, BodyPermissionId, Permission>>>,
location_pages: Rc<RwLock<PageIndexCache<LocationParentId, LocationId, Location>>>,
location_items: Rc<RwLock<ItemCache<LocationParentId, LocationId, Location>>>,
paper_pages: Rc<RwLock<PageIndexCache<PaperParentId, PaperId, Paper>>>,
paper_items: Rc<RwLock<ItemCache<PaperParentId, PaperId, Paper>>>,
}
impl<C: IsAuthenticated> IsAuthenticated for CachedClient<C> {
fn is_authenticated(&self) -> bool {
self.client.is_authenticated()
}
}
#[async_trait::async_trait(?Send)]
impl<C: PibClient> PibClient for CachedClient<C> {
type ClientError = C::ClientError;
async fn get(&self) -> Result<Index, Self::ClientError> {
self.client.get().await
}
async fn config_get(&self) -> Result<Config, Self::ClientError> {
self.client.config_get().await
}
async fn user_get(
&self,
pagination: Pagination,
search: Search,
) -> Result<DataPage<(), UserId, User>, Self::ClientError> {
let mut user_items = self.data.user_items.write().await;
let mut user_pages = self.data.user_pages.write().await;
user_pages
.get_page(&self.client, &mut user_items, (), pagination, search)
.await
}
async fn user_by_id_get(
&self,
user_id: UserId,
) -> Result<DataItem<(), UserId, User>, Self::ClientError> {
let mut user_items = self.data.user_items.write().await;
user_items.get(&self.client, (), user_id).await
}
async fn body_get(
&self,
pagination: Pagination,
search: Search,
) -> Result<DataPage<(), BodyId, Body>, Self::ClientError> {
let mut body_items = self.data.body_items.write().await;
let mut body_pages = self.data.body_pages.write().await;
body_pages
.get_page(&self.client, &mut body_items, (), pagination, search)
.await
}
async fn body_post(
&self,
new_body: Body,
) -> Result<DataItem<(), BodyId, Body>, Self::ClientError> {
let mut body_items = self.data.body_items.write().await;
let mut body_pages = self.data.body_pages.write().await;
let body_pages: &mut PageIndexCache<_, _, _> = &mut body_pages;
body_items
.create(&self.client, vec![body_pages], (), new_body)
.await
}
async fn body_by_id_or_alias_get(
&self,
body_id_or_alias: BodyIdOrAlias,
) -> Result<DataItem<(), BodyId, Body>, Self::ClientError> {
let mut body_items = self.data.body_items.write().await;
let mut body_aliases = self.data.body_aliases.write().await;
body_aliases
.get_by_alias(&self.client, (), body_id_or_alias, &mut body_items)
.await
}
async fn body_by_id_or_alias_patch(
&self,
body_id_or_alias: BodyIdOrAlias,
update_body: UpdateBody,
) -> Result<DataItem<(), BodyId, Body>, Self::ClientError> {
let mut body_items = self.data.body_items.write().await;
let mut body_aliases = self.data.body_aliases.write().await;
let item = body_aliases
.update_by_alias(
&self.client,
(),
body_id_or_alias,
update_body,
&mut body_items,
)
.await?;
Ok(item)
}
async fn body_by_id_or_alias_permission_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<PermissionParentId, BodyPermissionId, Permission>, Self::ClientError> {
let mut body_permission_items = self.data.body_permission_items.write().await;
let mut body_permission_pages = self.data.body_permission_pages.write().await;
body_permission_pages
.get_page(
&self.client,
&mut body_permission_items,
PermissionParentId { body_id },
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_permission_post(
&self,
body_id: BodyId,
new_permission: NewPermission,
) -> Result<DataItem<PermissionParentId, BodyPermissionId, Permission>, Self::ClientError> {
let mut body_permission_items = self.data.body_permission_items.write().await;
let mut body_permission_pages = self.data.body_permission_pages.write().await;
let body_permission_pages: &mut PageIndexCache<_, _, _> = &mut body_permission_pages;
body_permission_items
.create(
&self.client,
vec![body_permission_pages],
PermissionParentId { body_id },
new_permission,
)
.await
}
async fn body_by_id_or_alias_permission_by_id_get(
&self,
body_id: BodyId,
permission_id: BodyPermissionId,
) -> Result<DataItem<PermissionParentId, BodyPermissionId, Permission>, Self::ClientError> {
let mut body_permission_items = self.data.body_permission_items.write().await;
body_permission_items
.get(&self.client, PermissionParentId { body_id }, permission_id)
.await
}
async fn body_by_id_or_alias_meeting_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<MeetingParentId, MeetingId, Meeting>, Self::ClientError> {
let mut meeting_items = self.data.meeting_items.write().await;
let mut meeting_pages = self.data.meeting_pages.write().await;
meeting_pages
.get_page(
&self.client,
&mut meeting_items,
MeetingParentId { body_id },
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_meeting_post(
&self,
body_id: BodyId,
new_meeting: EditableMeeting,
) -> Result<DataItem<MeetingParentId, MeetingId, Meeting>, Self::ClientError> {
let mut meeting_items = self.data.meeting_items.write().await;
let mut meeting_pages = self.data.meeting_pages.write().await;
let meeting_pages: &mut PageIndexCache<_, _, _> = &mut meeting_pages;
meeting_items
.create(
&self.client,
vec![meeting_pages],
MeetingParentId { body_id },
new_meeting,
)
.await
}
async fn body_by_id_or_alias_meeting_by_id_get(
&self,
body_id: BodyId,
meeting_id: MeetingId,
) -> Result<DataItem<MeetingParentId, MeetingId, Meeting>, Self::ClientError> {
let mut meeting_items = self.data.meeting_items.write().await;
meeting_items
.get(&self.client, MeetingParentId { body_id }, meeting_id)
.await
}
async fn body_by_id_or_alias_meeting_by_id_patch(
&self,
body_id: BodyId,
meeting_id: MeetingId,
update_meeting: UpdateMeeting,
) -> Result<DataItem<MeetingParentId, MeetingId, Meeting>, Self::ClientError> {
let mut meeting_items = self.data.meeting_items.write().await;
let start_is_changed = update_meeting.start.is_some();
let updated_item = meeting_items
.update(
&self.client,
MeetingParentId { body_id },
meeting_id,
update_meeting,
)
.await?;
if start_is_changed {
let mut meeting_pages = self.data.meeting_pages.write().await;
meeting_pages.clear();
}
Ok(updated_item)
}
async fn body_by_id_or_alias_meeting_by_id_agenda_item_get(
&self,
body_id: BodyId,
meeting_id: MeetingId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<AgendaItemParentId, AgendaItemId, AgendaItem>, Self::ClientError> {
let mut agenda_item_items = self.data.agenda_item_items.write().await;
let mut agenda_item_pages = self.data.agenda_item_pages.write().await;
agenda_item_pages
.get_page(
&self.client,
&mut agenda_item_items,
AgendaItemParentId {
body_id,
meeting_id,
},
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_meeting_by_id_agenda_item_post(
&self,
body_id: BodyId,
meeting_id: MeetingId,
new_agenda_item: AgendaItem,
) -> Result<DataItem<AgendaItemParentId, AgendaItemId, AgendaItem>, Self::ClientError> {
let mut agenda_item_items = self.data.agenda_item_items.write().await;
let mut agenda_item_pages = self.data.agenda_item_pages.write().await;
let agenda_item_pages: &mut PageIndexCache<_, _, _> = &mut agenda_item_pages;
agenda_item_items
.create(
&self.client,
vec![agenda_item_pages],
AgendaItemParentId {
body_id,
meeting_id,
},
new_agenda_item,
)
.await
}
async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_get(
&self,
body_id: BodyId,
meeting_id: MeetingId,
agenda_item_id: AgendaItemId,
) -> Result<DataItem<AgendaItemParentId, AgendaItemId, AgendaItem>, Self::ClientError> {
let mut agenda_item_items = self.data.agenda_item_items.write().await;
agenda_item_items
.get(
&self.client,
AgendaItemParentId {
body_id,
meeting_id,
},
agenda_item_id,
)
.await
}
async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_patch(
&self,
body_id: BodyId,
meeting_id: MeetingId,
agenda_item_id: AgendaItemId,
update_agenda_item: UpdateAgendaItem,
) -> Result<DataItem<AgendaItemParentId, AgendaItemId, AgendaItem>, Self::ClientError> {
let mut agenda_item_items = self.data.agenda_item_items.write().await;
agenda_item_items
.update(
&self.client,
AgendaItemParentId {
body_id,
meeting_id,
},
agenda_item_id,
update_agenda_item,
)
.await
}
async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_consultation_get(
&self,
body_id: BodyId,
meeting_id: MeetingId,
agenda_item_id: AgendaItemId,
) -> Result<DataItem<ConsultationParentId, AgendaItemId, Consultation>, Self::ClientError> {
let mut consultation_items = self.data.consultation_items.write().await;
consultation_items
.get(
&self.client,
ConsultationParentId {
body_id,
meeting_id,
},
agenda_item_id,
)
.await
}
async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_consultation_put(
&self,
body_id: BodyId,
meeting_id: MeetingId,
agenda_item_id: AgendaItemId,
consultation: Consultation,
) -> Result<DataItem<ConsultationParentId, AgendaItemId, Consultation>, Self::ClientError> {
let mut consultation_items = self.data.consultation_items.write().await;
consultation_items
.place(
&self.client,
vec![],
ConsultationParentId {
body_id,
meeting_id,
},
agenda_item_id,
consultation,
)
.await
}
async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_consultation_patch(
&self,
body_id: BodyId,
meeting_id: MeetingId,
agenda_item_id: AgendaItemId,
update_consultation: UpdateConsultation,
) -> Result<DataItem<ConsultationParentId, AgendaItemId, Consultation>, Self::ClientError> {
let mut consultation_items = self.data.consultation_items.write().await;
consultation_items
.update(
&self.client,
ConsultationParentId {
body_id,
meeting_id,
},
agenda_item_id,
update_consultation,
)
.await
}
async fn body_by_id_or_alias_organization_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<OrganizationParentId, OrganizationId, Organization>, Self::ClientError>
{
let mut organization_items = self.data.organization_items.write().await;
let mut organization_pages = self.data.organization_pages.write().await;
organization_pages
.get_page(
&self.client,
&mut organization_items,
OrganizationParentId { body_id },
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_organization_post(
&self,
body_id: BodyId,
new_organization: Organization,
) -> Result<DataItem<OrganizationParentId, OrganizationId, Organization>, Self::ClientError>
{
let mut organization_items = self.data.organization_items.write().await;
let mut organization_pages = self.data.organization_pages.write().await;
let organization_pages: &mut PageIndexCache<_, _, _> = &mut organization_pages;
organization_items
.create(
&self.client,
vec![organization_pages],
OrganizationParentId { body_id },
new_organization,
)
.await
}
async fn body_by_id_or_alias_organization_by_id_get(
&self,
body_id: BodyId,
organization_id: OrganizationId,
) -> Result<DataItem<OrganizationParentId, OrganizationId, Organization>, Self::ClientError>
{
let mut organization_items = self.data.organization_items.write().await;
organization_items
.get(
&self.client,
OrganizationParentId { body_id },
organization_id,
)
.await
}
async fn body_by_id_or_alias_organization_by_id_patch(
&self,
body_id: BodyId,
organization_id: OrganizationId,
update_organization: UpdateOrganization,
) -> Result<DataItem<OrganizationParentId, OrganizationId, Organization>, Self::ClientError>
{
let mut organization_items = self.data.organization_items.write().await;
let updated_item = organization_items
.update(
&self.client,
OrganizationParentId { body_id },
organization_id,
update_organization,
)
.await?;
Ok(updated_item)
}
async fn body_by_id_or_alias_organization_by_id_membership_get(
&self,
body_id: BodyId,
organization_id: OrganizationId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<OrganizationMembershipParentId, MembershipId, Membership>, Self::ClientError>
{
let mut membership_items = self.data.membership_items.write().await;
let mut membership_organization_pages =
self.data.membership_organization_pages.write().await;
membership_organization_pages
.get_page(
&self.client,
&mut membership_items,
OrganizationMembershipParentId {
body_id,
organization_id,
},
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_organization_by_id_membership_post(
&self,
body_id: BodyId,
organization_id: OrganizationId,
new_membership: organization::by_id::membership::NewMembership,
) -> Result<DataItem<OrganizationMembershipParentId, MembershipId, Membership>, Self::ClientError>
{
let mut membership_items = self.data.membership_items.write().await;
let mut membership_pages = self.data.membership_pages.write().await;
let membership_pages: &mut PageIndexCache<_, _, _> = &mut membership_pages;
let mut membership_organization_pages =
self.data.membership_organization_pages.write().await;
let membership_organization_pages: &mut PageIndexCache<_, _, _> =
&mut membership_organization_pages;
let mut membership_person_pages = self.data.membership_person_pages.write().await;
let membership_person_pages: &mut PageIndexCache<_, _, _> = &mut membership_person_pages;
membership_items
.create(
&self.client,
vec![
membership_pages,
membership_organization_pages,
membership_person_pages,
],
OrganizationMembershipParentId {
body_id,
organization_id,
},
new_membership,
)
.await
}
async fn body_by_id_or_alias_organization_by_id_membership_by_id_get(
&self,
body_id: BodyId,
organization_id: OrganizationId,
membership_id: MembershipId,
) -> Result<DataItem<OrganizationMembershipParentId, MembershipId, Membership>, Self::ClientError>
{
let mut membership_items = self.data.membership_items.write().await;
let item = membership_items
.get(&self.client, MembershipParentId { body_id }, membership_id)
.await?;
Ok(DataItem {
id: item.id,
parent_id: OrganizationMembershipParentId {
body_id,
organization_id,
},
metadata: item.metadata,
value: item.value,
})
}
async fn body_by_id_or_alias_organization_by_id_membership_by_id_patch(
&self,
body_id: BodyId,
organization_id: OrganizationId,
membership_id: MembershipId,
update_membership: UpdateMembership,
) -> Result<DataItem<OrganizationMembershipParentId, MembershipId, Membership>, Self::ClientError>
{
let mut membership_items = self.data.membership_items.write().await;
let item = membership_items
.update(
&self.client,
MembershipParentId { body_id },
membership_id,
update_membership,
)
.await?;
Ok(DataItem {
id: item.id,
parent_id: OrganizationMembershipParentId {
body_id,
organization_id,
},
metadata: item.metadata,
value: item.value,
})
}
async fn body_by_id_or_alias_person_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<PersonParentId, PersonId, Person>, Self::ClientError> {
let mut person_items = self.data.person_items.write().await;
let mut person_pages = self.data.person_pages.write().await;
person_pages
.get_page(
&self.client,
&mut person_items,
PersonParentId { body_id },
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_person_post(
&self,
body_id: BodyId,
new_person: Person,
) -> Result<DataItem<PersonParentId, PersonId, Person>, Self::ClientError> {
let mut person_items = self.data.person_items.write().await;
let mut person_pages = self.data.person_pages.write().await;
let person_pages: &mut PageIndexCache<_, _, _> = &mut person_pages;
person_items
.create(
&self.client,
vec![person_pages],
PersonParentId { body_id },
new_person,
)
.await
}
async fn body_by_id_or_alias_person_by_id_get(
&self,
body_id: BodyId,
person_id: PersonId,
) -> Result<DataItem<PersonParentId, PersonId, Person>, Self::ClientError> {
let mut person_items = self.data.person_items.write().await;
person_items
.get(&self.client, PersonParentId { body_id }, person_id)
.await
}
async fn body_by_id_or_alias_person_by_id_patch(
&self,
body_id: BodyId,
person_id: PersonId,
update_person: UpdatePerson,
) -> Result<DataItem<PersonParentId, PersonId, Person>, Self::ClientError> {
let mut person_items = self.data.person_items.write().await;
let updated_item = person_items
.update(
&self.client,
PersonParentId { body_id },
person_id,
update_person,
)
.await?;
Ok(updated_item)
}
async fn body_by_id_or_alias_person_by_id_membership_get(
&self,
body_id: BodyId,
person_id: PersonId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<PersonMembershipParentId, MembershipId, Membership>, Self::ClientError>
{
let mut membership_items = self.data.membership_items.write().await;
let mut membership_person_pages = self.data.membership_person_pages.write().await;
membership_person_pages
.get_page(
&self.client,
&mut membership_items,
PersonMembershipParentId { body_id, person_id },
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_person_by_id_membership_post(
&self,
body_id: BodyId,
person_id: PersonId,
new_membership: person::by_id::membership::NewMembership,
) -> Result<DataItem<PersonMembershipParentId, MembershipId, Membership>, Self::ClientError>
{
let mut membership_items = self.data.membership_items.write().await;
let mut membership_pages = self.data.membership_pages.write().await;
let membership_pages: &mut PageIndexCache<_, _, _> = &mut membership_pages;
let mut membership_organization_pages =
self.data.membership_organization_pages.write().await;
let membership_organization_pages: &mut PageIndexCache<_, _, _> =
&mut membership_organization_pages;
let mut membership_person_pages = self.data.membership_person_pages.write().await;
let membership_person_pages: &mut PageIndexCache<_, _, _> = &mut membership_person_pages;
membership_items
.create(
&self.client,
vec![
membership_pages,
membership_organization_pages,
membership_person_pages,
],
PersonMembershipParentId { body_id, person_id },
new_membership,
)
.await
}
async fn body_by_id_or_alias_person_by_id_membership_by_id_get(
&self,
body_id: BodyId,
person_id: PersonId,
membership_id: MembershipId,
) -> Result<DataItem<PersonMembershipParentId, MembershipId, Membership>, Self::ClientError>
{
let mut membership_items = self.data.membership_items.write().await;
let item = membership_items
.get(&self.client, MembershipParentId { body_id }, membership_id)
.await?;
Ok(DataItem {
id: item.id,
parent_id: PersonMembershipParentId { body_id, person_id },
metadata: item.metadata,
value: item.value,
})
}
async fn body_by_id_or_alias_person_by_id_membership_by_id_patch(
&self,
body_id: BodyId,
person_id: PersonId,
membership_id: MembershipId,
update_membership: UpdateMembership,
) -> Result<DataItem<PersonMembershipParentId, MembershipId, Membership>, Self::ClientError>
{
let mut membership_items = self.data.membership_items.write().await;
let updated_item = membership_items
.update(
&self.client,
MembershipParentId { body_id },
membership_id,
update_membership,
)
.await?;
Ok(DataItem {
id: updated_item.id,
parent_id: PersonMembershipParentId { body_id, person_id },
metadata: updated_item.metadata,
value: updated_item.value,
})
}
async fn body_by_id_or_alias_membership_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<MembershipParentId, MembershipId, Membership>, Self::ClientError> {
let mut membership_items = self.data.membership_items.write().await;
let mut membership_pages = self.data.membership_pages.write().await;
membership_pages
.get_page(
&self.client,
&mut membership_items,
MembershipParentId { body_id },
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_membership_post(
&self,
body_id: BodyId,
new_membership: Membership,
) -> Result<DataItem<MembershipParentId, MembershipId, Membership>, Self::ClientError> {
let mut membership_items = self.data.membership_items.write().await;
let mut membership_pages = self.data.membership_pages.write().await;
let membership_pages: &mut PageIndexCache<_, _, _> = &mut membership_pages;
let mut membership_organization_pages = self.data.membership_pages.write().await;
let membership_organization_pages: &mut PageIndexCache<_, _, _> =
&mut membership_organization_pages;
let mut membership_person_pages = self.data.membership_pages.write().await;
let membership_person_pages: &mut PageIndexCache<_, _, _> = &mut membership_person_pages;
membership_items
.create(
&self.client,
vec![
membership_pages,
membership_organization_pages,
membership_person_pages,
],
MembershipParentId { body_id },
new_membership,
)
.await
}
async fn body_by_id_or_alias_membership_by_id_get(
&self,
body_id: BodyId,
membership_id: MembershipId,
) -> Result<DataItem<MembershipParentId, MembershipId, Membership>, Self::ClientError> {
let mut membership_items = self.data.membership_items.write().await;
membership_items
.get(&self.client, MembershipParentId { body_id }, membership_id)
.await
}
async fn body_by_id_or_alias_membership_by_id_patch(
&self,
body_id: BodyId,
membership_id: MembershipId,
update_membership: UpdateMembership,
) -> Result<DataItem<MembershipParentId, MembershipId, Membership>, Self::ClientError> {
let mut membership_items = self.data.membership_items.write().await;
membership_items
.update(
&self.client,
MembershipParentId { body_id },
membership_id,
update_membership,
)
.await
}
async fn body_by_id_or_alias_location_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<LocationParentId, LocationId, Location>, Self::ClientError> {
let mut location_items = self.data.location_items.write().await;
let mut location_pages = self.data.location_pages.write().await;
location_pages
.get_page(
&self.client,
&mut location_items,
LocationParentId { body_id },
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_location_post(
&self,
body_id: BodyId,
new_location: Location,
) -> Result<DataItem<LocationParentId, LocationId, Location>, Self::ClientError> {
let mut location_items = self.data.location_items.write().await;
let mut location_pages = self.data.location_pages.write().await;
let location_pages: &mut PageIndexCache<_, _, _> = &mut location_pages;
location_items
.create(
&self.client,
vec![location_pages],
LocationParentId { body_id },
new_location,
)
.await
}
async fn body_by_id_or_alias_location_by_id_get(
&self,
body_id: BodyId,
location_id: LocationId,
) -> Result<DataItem<LocationParentId, LocationId, Location>, Self::ClientError> {
let mut location_items = self.data.location_items.write().await;
location_items
.get(&self.client, LocationParentId { body_id }, location_id)
.await
}
async fn body_by_id_or_alias_location_by_id_patch(
&self,
body_id: BodyId,
location_id: LocationId,
update_location: UpdateLocation,
) -> Result<DataItem<LocationParentId, LocationId, Location>, Self::ClientError> {
let mut location_items = self.data.location_items.write().await;
location_items
.update(
&self.client,
LocationParentId { body_id },
location_id,
update_location,
)
.await
}
async fn body_by_id_or_alias_paper_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
) -> Result<DataPage<PaperParentId, PaperId, Paper>, Self::ClientError> {
let mut paper_items = self.data.paper_items.write().await;
let mut paper_pages = self.data.paper_pages.write().await;
paper_pages
.get_page(
&self.client,
&mut paper_items,
PaperParentId { body_id },
pagination,
search,
)
.await
}
async fn body_by_id_or_alias_paper_post(
&self,
body_id: BodyId,
new_paper: Paper,
) -> Result<DataItem<PaperParentId, PaperId, Paper>, Self::ClientError> {
let mut paper_items = self.data.paper_items.write().await;
let mut paper_pages = self.data.paper_pages.write().await;
let paper_pages: &mut PageIndexCache<_, _, _> = &mut paper_pages;
paper_items
.create(
&self.client,
vec![paper_pages],
PaperParentId { body_id },
new_paper,
)
.await
}
async fn body_by_id_or_alias_paper_by_id_get(
&self,
body_id: BodyId,
paper_id: PaperId,
) -> Result<DataItem<PaperParentId, PaperId, Paper>, Self::ClientError> {
let mut paper_items = self.data.paper_items.write().await;
paper_items
.get(&self.client, PaperParentId { body_id }, paper_id)
.await
}
async fn body_by_id_or_alias_paper_by_id_patch(
&self,
body_id: BodyId,
paper_id: PaperId,
update_paper: UpdatePaper,
) -> Result<DataItem<PaperParentId, PaperId, Paper>, Self::ClientError> {
let mut paper_items = self.data.paper_items.write().await;
paper_items
.update(
&self.client,
PaperParentId { body_id },
paper_id,
update_paper,
)
.await
}
async fn me_profile_get(&self) -> Result<Profile, Self::ClientError> {
{
let profile = self.data.profile.read().await;
if let Some(profile) = &*profile {
return Ok(profile.clone());
}
}
let mut lock = self.data.profile.write().await;
let profile = self.client.me_profile_get().await?;
_ = lock.insert(profile.clone());
Ok(profile)
}
async fn me_profile_patch(
&self,
update_profile: UpdateProfile,
) -> Result<Profile, Self::ClientError> {
let profile = self.client.me_profile_patch(update_profile).await?;
let mut lock = self.data.profile.write().await;
_ = lock.insert(profile.clone());
Ok(profile)
}
}
impl CachedData {
fn new() -> Self {
let profile = Rc::new(RwLock::new(None));
let body_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let body_items = Rc::new(RwLock::new(ItemCache::new()));
let body_aliases = Rc::new(RwLock::new(AliasCache::new()));
let user_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let user_items = Rc::new(RwLock::new(ItemCache::new()));
let meeting_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let meeting_items = Rc::new(RwLock::new(ItemCache::new()));
let agenda_item_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let agenda_item_items = Rc::new(RwLock::new(ItemCache::new()));
let consultation_items = Rc::new(RwLock::new(ItemCache::new()));
let organization_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let organization_items = Rc::new(RwLock::new(ItemCache::new()));
let person_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let person_items = Rc::new(RwLock::new(ItemCache::new()));
let membership_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let membership_organization_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let membership_person_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let membership_items = Rc::new(RwLock::new(ItemCache::new()));
let body_permission_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let body_permission_items = Rc::new(RwLock::new(ItemCache::new()));
let location_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let location_items = Rc::new(RwLock::new(ItemCache::new()));
let paper_pages = Rc::new(RwLock::new(PageIndexCache::new()));
let paper_items = Rc::new(RwLock::new(ItemCache::new()));
Self {
profile,
body_pages,
body_items,
body_aliases,
user_pages,
user_items,
meeting_pages,
meeting_items,
agenda_item_pages,
agenda_item_items,
consultation_items,
organization_pages,
organization_items,
person_pages,
person_items,
membership_pages,
membership_organization_pages,
membership_person_pages,
membership_items,
body_permission_pages,
body_permission_items,
location_pages,
location_items,
paper_pages,
paper_items,
}
}
}
trait ClearableCache {
fn clear_cache(&mut self);
}