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::{
Associated, AssociatedEntities, Index, ItemResponse, PagedResponse, Pagination, Search,
body::{
Body, UpdateBody,
by_id_or_alias::{
location::{self, Location, UpdateLocation},
meeting::{
self, EditableMeeting, Meeting, UpdateMeeting,
by_id::agenda_item::{
self, AgendaItem, UpdateAgendaItem,
by_id::consultation::{self, Consultation, UpdateConsultation},
},
},
membership::{self, Membership, UpdateMembership},
organization::{self, Organization, UpdateOrganization},
paper::{self, Paper, UpdatePaper},
paper_location::{self, PaperLocation},
permission::{self, NewPermission, Permission},
person::{self, NewPerson, Person, UpdatePerson},
},
},
config::Config,
me::profile::{Profile, UpdateProfile},
user::User,
};
use pib_service_core_types::{
AgendaItemId, BodyId, BodyIdOrAlias, BodyPermissionId, DataItem, LocationId, MeetingId,
MembershipId, OrganizationId, PaperId, PaperLocationId, 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<meeting::ParentId, MeetingId, Meeting>>>,
meeting_items: Rc<RwLock<ItemCache<meeting::ParentId, MeetingId, Meeting>>>,
agenda_item_pages: Rc<RwLock<PageIndexCache<agenda_item::ParentId, AgendaItemId, AgendaItem>>>,
agenda_item_items: Rc<RwLock<ItemCache<agenda_item::ParentId, AgendaItemId, AgendaItem>>>,
consultation_items: Rc<RwLock<ItemCache<consultation::ParentId, AgendaItemId, Consultation>>>,
organization_pages:
Rc<RwLock<PageIndexCache<organization::ParentId, OrganizationId, Organization>>>,
organization_items: Rc<RwLock<ItemCache<organization::ParentId, OrganizationId, Organization>>>,
person_pages: Rc<RwLock<PageIndexCache<person::ParentId, PersonId, Person>>>,
person_items: Rc<RwLock<ItemCache<person::ParentId, PersonId, Person>>>,
membership_pages: Rc<RwLock<PageIndexCache<membership::ParentId, MembershipId, Membership>>>,
membership_organization_pages: Rc<
RwLock<PageIndexCache<organization::by_id::membership::ParentId, MembershipId, Membership>>,
>,
membership_person_pages:
Rc<RwLock<PageIndexCache<person::by_id::membership::ParentId, MembershipId, Membership>>>,
membership_items: Rc<RwLock<ItemCache<membership::ParentId, MembershipId, Membership>>>,
body_permission_pages:
Rc<RwLock<PageIndexCache<permission::ParentId, BodyPermissionId, Permission>>>,
body_permission_items:
Rc<RwLock<ItemCache<permission::ParentId, BodyPermissionId, Permission>>>,
location_pages: Rc<RwLock<PageIndexCache<location::ParentId, LocationId, Location>>>,
location_items: Rc<RwLock<ItemCache<location::ParentId, LocationId, Location>>>,
paper_pages: Rc<RwLock<PageIndexCache<paper::ParentId, PaperId, Paper>>>,
paper_items: Rc<RwLock<ItemCache<paper::ParentId, PaperId, Paper>>>,
paper_location_items:
Rc<RwLock<ItemCache<paper_location::ParentId, PaperLocationId, PaperLocation>>>,
}
impl<C: IsAuthenticated> IsAuthenticated for CachedClient<C> {
fn is_authenticated(&self) -> bool {
self.client.is_authenticated()
}
}
impl<C> CachedClient<C> {
async fn store_associated_entities(
&self,
AssociatedEntities {
bodies,
persons,
memberships,
meetings,
agenda_items,
consultations,
papers,
locations,
paper_locations,
organizations,
}: AssociatedEntities,
) {
if !bodies.is_empty() {
let mut body_items = self.data.body_items.write().await;
body_items.insert_many(bodies.into_values());
}
if !persons.is_empty() {
let mut person_items = self.data.person_items.write().await;
person_items.insert_many(persons.into_values());
}
if !memberships.is_empty() {
let mut membership_items = self.data.membership_items.write().await;
membership_items.insert_many(memberships.into_values());
}
if !meetings.is_empty() {
let mut meeting_items = self.data.meeting_items.write().await;
meeting_items.insert_many(meetings.into_values());
}
if !agenda_items.is_empty() {
let mut agenda_item_items = self.data.agenda_item_items.write().await;
agenda_item_items.insert_many(agenda_items.into_values());
}
if !consultations.is_empty() {
let mut consultation_items = self.data.consultation_items.write().await;
consultation_items.insert_many(consultations.into_values());
}
if !papers.is_empty() {
let mut paper_items = self.data.paper_items.write().await;
paper_items.insert_many(papers.into_values());
}
if !locations.is_empty() {
let mut location_items = self.data.location_items.write().await;
location_items.insert_many(locations.into_values());
}
if !paper_locations.is_empty() {
let mut paper_location_items = self.data.paper_location_items.write().await;
paper_location_items.insert_many(paper_locations.into_values());
}
if !organizations.is_empty() {
let mut organization_items = self.data.organization_items.write().await;
organization_items.insert_many(organizations.into_values());
}
}
}
#[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,
associated: Associated,
) -> Result<PagedResponse<(), UserId, User>, Self::ClientError> {
let r = {
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,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn user_by_id_get(
&self,
user_id: UserId,
associated: Associated,
) -> Result<ItemResponse<(), UserId, User>, Self::ClientError> {
let r = {
let mut user_items = self.data.user_items.write().await;
user_items
.get(&self.client, (), user_id, associated)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_get(
&self,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<PagedResponse<(), BodyId, Body>, Self::ClientError> {
let r = {
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,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_post(
&self,
new_body: Body,
) -> Result<ItemResponse<(), BodyId, Body>, Self::ClientError> {
let r = {
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?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_get(
&self,
body_id_or_alias: BodyIdOrAlias,
associated: Associated,
) -> Result<ItemResponse<(), BodyId, Body>, Self::ClientError> {
let r = {
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,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_patch(
&self,
body_id_or_alias: BodyIdOrAlias,
update_body: UpdateBody,
) -> Result<ItemResponse<(), BodyId, Body>, Self::ClientError> {
let r = {
let mut body_items = self.data.body_items.write().await;
let mut body_aliases = self.data.body_aliases.write().await;
body_aliases
.update_by_alias(
&self.client,
(),
body_id_or_alias,
update_body,
&mut body_items,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_permission_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<PagedResponse<permission::ParentId, BodyPermissionId, Permission>, Self::ClientError>
{
let r = {
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,
permission::ParentId { body_id },
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_permission_post(
&self,
body_id: BodyId,
new_permission: NewPermission,
) -> Result<ItemResponse<permission::ParentId, BodyPermissionId, Permission>, Self::ClientError>
{
let r = {
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],
permission::ParentId { body_id },
new_permission,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_permission_by_id_get(
&self,
body_id: BodyId,
permission_id: BodyPermissionId,
associated: Associated,
) -> Result<ItemResponse<permission::ParentId, BodyPermissionId, Permission>, Self::ClientError>
{
let r = {
let mut body_permission_items = self.data.body_permission_items.write().await;
body_permission_items
.get(
&self.client,
permission::ParentId { body_id },
permission_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_meeting_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<PagedResponse<meeting::ParentId, MeetingId, Meeting>, Self::ClientError> {
let r = {
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,
meeting::ParentId { body_id },
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_meeting_post(
&self,
body_id: BodyId,
new_meeting: EditableMeeting,
) -> Result<ItemResponse<meeting::ParentId, MeetingId, Meeting>, Self::ClientError> {
let r = {
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],
meeting::ParentId { body_id },
new_meeting,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_meeting_by_id_get(
&self,
body_id: BodyId,
meeting_id: MeetingId,
associated: Associated,
) -> Result<ItemResponse<meeting::ParentId, MeetingId, Meeting>, Self::ClientError> {
let r = {
let mut meeting_items = self.data.meeting_items.write().await;
meeting_items
.get(
&self.client,
meeting::ParentId { body_id },
meeting_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_meeting_by_id_patch(
&self,
body_id: BodyId,
meeting_id: MeetingId,
update_meeting: UpdateMeeting,
) -> Result<ItemResponse<meeting::ParentId, MeetingId, Meeting>, Self::ClientError> {
let r = {
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,
meeting::ParentId { body_id },
meeting_id,
update_meeting,
)
.await?;
if start_is_changed {
let mut meeting_pages = self.data.meeting_pages.write().await;
meeting_pages.clear();
}
updated_item
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_meeting_by_id_agenda_item_get(
&self,
body_id: BodyId,
meeting_id: MeetingId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<PagedResponse<agenda_item::ParentId, AgendaItemId, AgendaItem>, Self::ClientError>
{
let r = {
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,
agenda_item::ParentId {
body_id,
meeting_id,
},
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
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<ItemResponse<agenda_item::ParentId, AgendaItemId, AgendaItem>, Self::ClientError>
{
let r = {
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],
agenda_item::ParentId {
body_id,
meeting_id,
},
new_agenda_item,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
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,
associated: Associated,
) -> Result<ItemResponse<agenda_item::ParentId, AgendaItemId, AgendaItem>, Self::ClientError>
{
let r = {
let mut agenda_item_items = self.data.agenda_item_items.write().await;
agenda_item_items
.get(
&self.client,
agenda_item::ParentId {
body_id,
meeting_id,
},
agenda_item_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
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<ItemResponse<agenda_item::ParentId, AgendaItemId, AgendaItem>, Self::ClientError>
{
let r = {
let mut agenda_item_items = self.data.agenda_item_items.write().await;
agenda_item_items
.update(
&self.client,
agenda_item::ParentId {
body_id,
meeting_id,
},
agenda_item_id,
update_agenda_item,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
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,
associated: Associated,
) -> Result<ItemResponse<consultation::ParentId, AgendaItemId, Consultation>, Self::ClientError>
{
let r = {
let mut consultation_items = self.data.consultation_items.write().await;
consultation_items
.get(
&self.client,
consultation::ParentId {
body_id,
meeting_id,
},
agenda_item_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
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<ItemResponse<consultation::ParentId, AgendaItemId, Consultation>, Self::ClientError>
{
let r = {
let mut consultation_items = self.data.consultation_items.write().await;
consultation_items
.place(
&self.client,
vec![],
consultation::ParentId {
body_id,
meeting_id,
},
agenda_item_id,
consultation,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
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<ItemResponse<consultation::ParentId, AgendaItemId, Consultation>, Self::ClientError>
{
let r = {
let mut consultation_items = self.data.consultation_items.write().await;
consultation_items
.update(
&self.client,
consultation::ParentId {
body_id,
meeting_id,
},
agenda_item_id,
update_consultation,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_organization_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<
PagedResponse<organization::ParentId, OrganizationId, Organization>,
Self::ClientError,
> {
let r = {
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,
organization::ParentId { body_id },
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_organization_post(
&self,
body_id: BodyId,
new_organization: Organization,
) -> Result<ItemResponse<organization::ParentId, OrganizationId, Organization>, Self::ClientError>
{
let r = {
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],
organization::ParentId { body_id },
new_organization,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_organization_by_id_get(
&self,
body_id: BodyId,
organization_id: OrganizationId,
associated: Associated,
) -> Result<ItemResponse<organization::ParentId, OrganizationId, Organization>, Self::ClientError>
{
let r = {
let mut organization_items = self.data.organization_items.write().await;
organization_items
.get(
&self.client,
organization::ParentId { body_id },
organization_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_organization_by_id_patch(
&self,
body_id: BodyId,
organization_id: OrganizationId,
update_organization: UpdateOrganization,
) -> Result<ItemResponse<organization::ParentId, OrganizationId, Organization>, Self::ClientError>
{
let r = {
let mut organization_items = self.data.organization_items.write().await;
organization_items
.update(
&self.client,
organization::ParentId { body_id },
organization_id,
update_organization,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_organization_by_id_membership_get(
&self,
body_id: BodyId,
organization_id: OrganizationId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<
PagedResponse<organization::by_id::membership::ParentId, MembershipId, Membership>,
Self::ClientError,
> {
let r = {
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,
organization::by_id::membership::ParentId {
body_id,
organization_id,
},
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
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<
ItemResponse<organization::by_id::membership::ParentId, MembershipId, Membership>,
Self::ClientError,
> {
let r = {
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,
],
organization::by_id::membership::ParentId {
body_id,
organization_id,
},
new_membership,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_organization_by_id_membership_by_id_get(
&self,
body_id: BodyId,
organization_id: OrganizationId,
membership_id: MembershipId,
associated: Associated,
) -> Result<
ItemResponse<organization::by_id::membership::ParentId, MembershipId, Membership>,
Self::ClientError,
> {
let r = {
let mut membership_items = self.data.membership_items.write().await;
membership_items
.get(
&self.client,
membership::ParentId { body_id },
membership_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(DataItem {
id: r.value.id,
parent_id: organization::by_id::membership::ParentId {
body_id,
organization_id,
},
metadata: r.value.metadata,
value: r.value.value,
}
.into())
}
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<
ItemResponse<organization::by_id::membership::ParentId, MembershipId, Membership>,
Self::ClientError,
> {
let r = {
let mut membership_items = self.data.membership_items.write().await;
membership_items
.update(
&self.client,
membership::ParentId { body_id },
membership_id,
update_membership,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(DataItem {
id: r.value.id,
parent_id: organization::by_id::membership::ParentId {
body_id,
organization_id,
},
metadata: r.value.metadata,
value: r.value.value,
}
.into())
}
async fn body_by_id_or_alias_person_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<PagedResponse<person::ParentId, PersonId, Person>, Self::ClientError> {
let r = {
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,
person::ParentId { body_id },
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_person_post(
&self,
body_id: BodyId,
new_person: NewPerson,
) -> Result<ItemResponse<person::ParentId, PersonId, Person>, Self::ClientError> {
let r = {
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],
person::ParentId { body_id },
new_person,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_person_by_id_get(
&self,
body_id: BodyId,
person_id: PersonId,
associated: Associated,
) -> Result<ItemResponse<person::ParentId, PersonId, Person>, Self::ClientError> {
let r = {
let mut person_items = self.data.person_items.write().await;
person_items
.get(
&self.client,
person::ParentId { body_id },
person_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_person_by_id_patch(
&self,
body_id: BodyId,
person_id: PersonId,
update_person: UpdatePerson,
) -> Result<ItemResponse<person::ParentId, PersonId, Person>, Self::ClientError> {
let r = {
let mut person_items = self.data.person_items.write().await;
person_items
.update(
&self.client,
person::ParentId { body_id },
person_id,
update_person,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_person_by_id_membership_get(
&self,
body_id: BodyId,
person_id: PersonId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<
PagedResponse<person::by_id::membership::ParentId, MembershipId, Membership>,
Self::ClientError,
> {
let r = {
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,
person::by_id::membership::ParentId { body_id, person_id },
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
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<
ItemResponse<person::by_id::membership::ParentId, MembershipId, Membership>,
Self::ClientError,
> {
let r = {
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,
],
person::by_id::membership::ParentId { body_id, person_id },
new_membership,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_person_by_id_membership_by_id_get(
&self,
body_id: BodyId,
person_id: PersonId,
membership_id: MembershipId,
associated: Associated,
) -> Result<
ItemResponse<person::by_id::membership::ParentId, MembershipId, Membership>,
Self::ClientError,
> {
let r = {
let mut membership_items = self.data.membership_items.write().await;
membership_items
.get(
&self.client,
membership::ParentId { body_id },
membership_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(DataItem {
id: r.value.id,
parent_id: person::by_id::membership::ParentId { body_id, person_id },
metadata: r.value.metadata,
value: r.value.value,
}
.into())
}
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<
ItemResponse<person::by_id::membership::ParentId, MembershipId, Membership>,
Self::ClientError,
> {
let r = {
let mut membership_items = self.data.membership_items.write().await;
membership_items
.update(
&self.client,
membership::ParentId { body_id },
membership_id,
update_membership,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(DataItem {
id: r.value.id,
parent_id: person::by_id::membership::ParentId { body_id, person_id },
metadata: r.value.metadata,
value: r.value.value,
}
.into())
}
async fn body_by_id_or_alias_membership_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<PagedResponse<membership::ParentId, MembershipId, Membership>, Self::ClientError>
{
let r = {
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,
membership::ParentId { body_id },
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_membership_post(
&self,
body_id: BodyId,
new_membership: Membership,
) -> Result<ItemResponse<membership::ParentId, MembershipId, Membership>, Self::ClientError>
{
let r = {
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,
],
membership::ParentId { body_id },
new_membership,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_membership_by_id_get(
&self,
body_id: BodyId,
membership_id: MembershipId,
associated: Associated,
) -> Result<ItemResponse<membership::ParentId, MembershipId, Membership>, Self::ClientError>
{
let r = {
let mut membership_items = self.data.membership_items.write().await;
membership_items
.get(
&self.client,
membership::ParentId { body_id },
membership_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_membership_by_id_patch(
&self,
body_id: BodyId,
membership_id: MembershipId,
update_membership: UpdateMembership,
) -> Result<ItemResponse<membership::ParentId, MembershipId, Membership>, Self::ClientError>
{
let r = {
let mut membership_items = self.data.membership_items.write().await;
membership_items
.update(
&self.client,
membership::ParentId { body_id },
membership_id,
update_membership,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_location_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<PagedResponse<location::ParentId, LocationId, Location>, Self::ClientError> {
let r = {
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,
location::ParentId { body_id },
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_location_post(
&self,
body_id: BodyId,
new_location: Location,
) -> Result<ItemResponse<location::ParentId, LocationId, Location>, Self::ClientError> {
let r = {
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],
location::ParentId { body_id },
new_location,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_location_by_id_get(
&self,
body_id: BodyId,
location_id: LocationId,
associated: Associated,
) -> Result<ItemResponse<location::ParentId, LocationId, Location>, Self::ClientError> {
let r = {
let mut location_items = self.data.location_items.write().await;
location_items
.get(
&self.client,
location::ParentId { body_id },
location_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_location_by_id_patch(
&self,
body_id: BodyId,
location_id: LocationId,
update_location: UpdateLocation,
) -> Result<ItemResponse<location::ParentId, LocationId, Location>, Self::ClientError> {
let r = {
let mut location_items = self.data.location_items.write().await;
location_items
.update(
&self.client,
location::ParentId { body_id },
location_id,
update_location,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_paper_get(
&self,
body_id: BodyId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<PagedResponse<paper::ParentId, PaperId, Paper>, Self::ClientError> {
let r = {
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,
paper::ParentId { body_id },
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_paper_post(
&self,
body_id: BodyId,
new_paper: Paper,
) -> Result<ItemResponse<paper::ParentId, PaperId, Paper>, Self::ClientError> {
let r = {
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],
paper::ParentId { body_id },
new_paper,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_paper_by_id_get(
&self,
body_id: BodyId,
paper_id: PaperId,
associated: Associated,
) -> Result<ItemResponse<paper::ParentId, PaperId, Paper>, Self::ClientError> {
let r = {
let mut paper_items = self.data.paper_items.write().await;
paper_items
.get(
&self.client,
paper::ParentId { body_id },
paper_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_paper_by_id_patch(
&self,
body_id: BodyId,
paper_id: PaperId,
update_paper: UpdatePaper,
) -> Result<ItemResponse<paper::ParentId, PaperId, Paper>, Self::ClientError> {
let r = {
let mut paper_items = self.data.paper_items.write().await;
paper_items
.update(
&self.client,
paper::ParentId { body_id },
paper_id,
update_paper,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_location_by_id_paper_get(
&self,
body_id: BodyId,
location_id: LocationId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<
PagedResponse<
location::by_id::paper::ParentId,
PaperLocationId,
paper_location::PaperLocation,
>,
Self::ClientError,
> {
let r = {
self.client
.body_by_id_or_alias_location_by_id_paper_get(
body_id,
location_id,
pagination,
search,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_location_by_id_paper_post(
&self,
body_id: BodyId,
location_id: LocationId,
new_paper: location::by_id::paper::NewPaperLocation,
) -> Result<
ItemResponse<
location::by_id::paper::ParentId,
PaperLocationId,
paper_location::PaperLocation,
>,
Self::ClientError,
> {
let r = {
self.client
.body_by_id_or_alias_location_by_id_paper_post(body_id, location_id, new_paper)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_location_by_id_paper_by_id_get(
&self,
body_id: BodyId,
location_id: LocationId,
paper_location_id: PaperLocationId,
associated: Associated,
) -> Result<
ItemResponse<
location::by_id::paper::ParentId,
PaperLocationId,
paper_location::PaperLocation,
>,
Self::ClientError,
> {
let r = {
self.client
.body_by_id_or_alias_location_by_id_paper_by_id_get(
body_id,
location_id,
paper_location_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_location_by_id_paper_by_id_delete(
&self,
body_id: BodyId,
location_id: LocationId,
paper_location_id: PaperLocationId,
) -> Result<(), Self::ClientError> {
self.client
.body_by_id_or_alias_location_by_id_paper_by_id_delete(
body_id,
location_id,
paper_location_id,
)
.await
}
async fn body_by_id_or_alias_paper_by_id_location_get(
&self,
body_id: BodyId,
paper_id: PaperId,
pagination: Pagination,
search: Search,
associated: Associated,
) -> Result<
PagedResponse<
paper::by_id::location::ParentId,
PaperLocationId,
paper_location::PaperLocation,
>,
Self::ClientError,
> {
let r = {
self.client
.body_by_id_or_alias_paper_by_id_location_get(
body_id, paper_id, pagination, search, associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_paper_by_id_location_post(
&self,
body_id: BodyId,
paper_id: PaperId,
new_location: paper::by_id::location::NewPaperLocation,
) -> Result<
ItemResponse<
paper::by_id::location::ParentId,
PaperLocationId,
paper_location::PaperLocation,
>,
Self::ClientError,
> {
let r = {
self.client
.body_by_id_or_alias_paper_by_id_location_post(body_id, paper_id, new_location)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_paper_by_id_location_by_id_get(
&self,
body_id: BodyId,
paper_id: PaperId,
paper_location_id: PaperLocationId,
associated: Associated,
) -> Result<
ItemResponse<
paper::by_id::location::ParentId,
PaperLocationId,
paper_location::PaperLocation,
>,
Self::ClientError,
> {
let r = {
self.client
.body_by_id_or_alias_paper_by_id_location_by_id_get(
body_id,
paper_id,
paper_location_id,
associated,
)
.await?
};
self.store_associated_entities(r.associated.clone()).await;
Ok(r)
}
async fn body_by_id_or_alias_paper_by_id_location_by_id_delete(
&self,
body_id: BodyId,
paper_id: PaperId,
paper_location_id: PaperLocationId,
) -> Result<(), Self::ClientError> {
self.client
.body_by_id_or_alias_paper_by_id_location_by_id_delete(
body_id,
paper_id,
paper_location_id,
)
.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()));
let paper_location_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,
paper_location_items,
}
}
}
trait ClearableCache {
fn clear_cache(&mut self);
}