Skip to main content

pib_client_cached/
lib.rs

1// SPDX-FileCopyrightText: Politik im Blick developers
2// SPDX-FileCopyrightText: Wolfgang Silbermayr <wolfgang@silbermayr.at>
3//
4// SPDX-License-Identifier: AGPL-3.0-or-later OR EUPL-1.2
5
6mod alias_cache;
7mod item;
8mod item_cache;
9mod page_index_cache;
10
11use std::rc::Rc;
12
13use cachekit::prelude::CachePolicy;
14use item::{CreateableItem, PageableItem};
15use pib_client::{IsAuthenticated, PibClient};
16use pib_service_api_types::{
17    Associated, AssociatedEntities, Index, ItemResponse, PagedResponse, Pagination, Search,
18    body::{
19        Body, UpdateBody,
20        by_id_or_alias::{
21            location::{self, Location, NewLocation, UpdateLocation},
22            meeting::{
23                self, EditableMeeting, Meeting, UpdateMeeting,
24                by_id::agenda_item::{
25                    self, AgendaItem, UpdateAgendaItem,
26                    by_id::consultation::{self, Consultation, UpdateConsultation},
27                },
28            },
29            membership::{self, Membership, UpdateMembership},
30            organization::{self, NewOrganization, Organization, UpdateOrganization},
31            paper::{self, NewPaper, Paper, UpdatePaper},
32            paper_location::{self, PaperLocation},
33            permission::{self, NewPermission, Permission},
34            person::{self, NewPerson, Person, UpdatePerson},
35        },
36    },
37    config::Config,
38    me::profile::{Profile, UpdateProfile},
39    user::User,
40};
41use pib_service_core_types::{
42    AgendaItemId, BodyId, BodyIdOrAlias, BodyPermissionId, DataItem, LocationId, MeetingId,
43    MembershipId, OrganizationId, PaperId, PaperLocationId, PersonId, UserId,
44};
45use tokio::sync::RwLock;
46
47use crate::alias_cache::AliasCache;
48
49use self::{item_cache::ItemCache, page_index_cache::PageIndexCache};
50
51const CACHE_SIZE: usize = 1000;
52const CACHE_POLICY: CachePolicy = CachePolicy::Lru;
53
54#[derive(Debug, Clone)]
55pub struct CachedClient<C> {
56    client: C,
57    data: CachedData,
58}
59
60impl<C> CachedClient<C> {
61    pub fn new(client: C) -> Self {
62        Self {
63            client,
64            data: CachedData::new(),
65        }
66    }
67}
68
69#[derive(Debug, Clone)]
70struct CachedData {
71    profile: Rc<RwLock<Option<pib_service_api_types::me::profile::Profile>>>,
72
73    body_pages: Rc<RwLock<PageIndexCache<(), BodyId, Body>>>,
74    body_items: Rc<RwLock<ItemCache<(), BodyId, Body>>>,
75    body_aliases: Rc<RwLock<AliasCache<(), BodyIdOrAlias, BodyId>>>,
76
77    user_pages: Rc<RwLock<PageIndexCache<(), UserId, User>>>,
78    user_items: Rc<RwLock<ItemCache<(), UserId, User>>>,
79
80    meeting_pages: Rc<RwLock<PageIndexCache<meeting::ParentId, MeetingId, Meeting>>>,
81    meeting_items: Rc<RwLock<ItemCache<meeting::ParentId, MeetingId, Meeting>>>,
82
83    agenda_item_pages: Rc<RwLock<PageIndexCache<agenda_item::ParentId, AgendaItemId, AgendaItem>>>,
84    agenda_item_items: Rc<RwLock<ItemCache<agenda_item::ParentId, AgendaItemId, AgendaItem>>>,
85
86    consultation_items: Rc<RwLock<ItemCache<consultation::ParentId, AgendaItemId, Consultation>>>,
87
88    organization_pages:
89        Rc<RwLock<PageIndexCache<organization::ParentId, OrganizationId, Organization>>>,
90    organization_items: Rc<RwLock<ItemCache<organization::ParentId, OrganizationId, Organization>>>,
91
92    person_pages: Rc<RwLock<PageIndexCache<person::ParentId, PersonId, Person>>>,
93    person_items: Rc<RwLock<ItemCache<person::ParentId, PersonId, Person>>>,
94
95    membership_pages: Rc<RwLock<PageIndexCache<membership::ParentId, MembershipId, Membership>>>,
96    membership_organization_pages: Rc<
97        RwLock<PageIndexCache<organization::by_id::membership::ParentId, MembershipId, Membership>>,
98    >,
99    membership_person_pages:
100        Rc<RwLock<PageIndexCache<person::by_id::membership::ParentId, MembershipId, Membership>>>,
101    membership_items: Rc<RwLock<ItemCache<membership::ParentId, MembershipId, Membership>>>,
102
103    body_permission_pages:
104        Rc<RwLock<PageIndexCache<permission::ParentId, BodyPermissionId, Permission>>>,
105    body_permission_items:
106        Rc<RwLock<ItemCache<permission::ParentId, BodyPermissionId, Permission>>>,
107
108    location_pages: Rc<RwLock<PageIndexCache<location::ParentId, LocationId, Location>>>,
109    location_items: Rc<RwLock<ItemCache<location::ParentId, LocationId, Location>>>,
110
111    paper_pages: Rc<RwLock<PageIndexCache<paper::ParentId, PaperId, Paper>>>,
112    paper_items: Rc<RwLock<ItemCache<paper::ParentId, PaperId, Paper>>>,
113
114    paper_location_items:
115        Rc<RwLock<ItemCache<paper_location::ParentId, PaperLocationId, PaperLocation>>>,
116}
117
118impl<C: IsAuthenticated> IsAuthenticated for CachedClient<C> {
119    fn is_authenticated(&self) -> bool {
120        self.client.is_authenticated()
121    }
122}
123
124impl<C> CachedClient<C> {
125    async fn store_associated_entities(
126        &self,
127        AssociatedEntities {
128            bodies,
129            persons,
130            memberships,
131            meetings,
132            agenda_items,
133            consultations,
134            papers,
135            locations,
136            paper_locations,
137            organizations,
138        }: AssociatedEntities,
139    ) {
140        if !bodies.is_empty() {
141            let mut body_items = self.data.body_items.write().await;
142            body_items.insert_many(bodies.into_values());
143        }
144
145        if !persons.is_empty() {
146            let mut person_items = self.data.person_items.write().await;
147            person_items.insert_many(persons.into_values());
148        }
149
150        if !memberships.is_empty() {
151            let mut membership_items = self.data.membership_items.write().await;
152            membership_items.insert_many(memberships.into_values());
153        }
154
155        if !meetings.is_empty() {
156            let mut meeting_items = self.data.meeting_items.write().await;
157            meeting_items.insert_many(meetings.into_values());
158        }
159
160        if !agenda_items.is_empty() {
161            let mut agenda_item_items = self.data.agenda_item_items.write().await;
162            agenda_item_items.insert_many(agenda_items.into_values());
163        }
164
165        if !consultations.is_empty() {
166            let mut consultation_items = self.data.consultation_items.write().await;
167            consultation_items.insert_many(consultations.into_values());
168        }
169
170        if !papers.is_empty() {
171            let mut paper_items = self.data.paper_items.write().await;
172            paper_items.insert_many(papers.into_values());
173        }
174
175        if !locations.is_empty() {
176            let mut location_items = self.data.location_items.write().await;
177            location_items.insert_many(locations.into_values());
178        }
179
180        if !paper_locations.is_empty() {
181            let mut paper_location_items = self.data.paper_location_items.write().await;
182            paper_location_items.insert_many(paper_locations.into_values());
183        }
184
185        if !organizations.is_empty() {
186            let mut organization_items = self.data.organization_items.write().await;
187            organization_items.insert_many(organizations.into_values());
188        }
189    }
190}
191
192#[async_trait::async_trait(?Send)]
193impl<C: PibClient> PibClient for CachedClient<C> {
194    type ClientError = C::ClientError;
195
196    async fn get(&self) -> Result<Index, Self::ClientError> {
197        self.client.get().await
198    }
199
200    async fn config_get(&self) -> Result<Config, Self::ClientError> {
201        self.client.config_get().await
202    }
203
204    async fn user_get(
205        &self,
206        pagination: Pagination,
207        search: Search,
208        associated: Associated,
209    ) -> Result<PagedResponse<(), UserId, User>, Self::ClientError> {
210        let r = {
211            let mut user_items = self.data.user_items.write().await;
212            let mut user_pages = self.data.user_pages.write().await;
213            user_pages
214                .get_page(
215                    &self.client,
216                    &mut user_items,
217                    (),
218                    pagination,
219                    search,
220                    associated,
221                )
222                .await?
223        };
224        self.store_associated_entities(r.associated.clone()).await;
225        Ok(r)
226    }
227
228    async fn user_by_id_get(
229        &self,
230        user_id: UserId,
231        associated: Associated,
232    ) -> Result<ItemResponse<(), UserId, User>, Self::ClientError> {
233        let r = {
234            let mut user_items = self.data.user_items.write().await;
235            user_items
236                .get(&self.client, (), user_id, associated)
237                .await?
238        };
239        self.store_associated_entities(r.associated.clone()).await;
240        Ok(r)
241    }
242
243    async fn body_get(
244        &self,
245        pagination: Pagination,
246        search: Search,
247        associated: Associated,
248    ) -> Result<PagedResponse<(), BodyId, Body>, Self::ClientError> {
249        let r = {
250            let mut body_items = self.data.body_items.write().await;
251            let mut body_pages = self.data.body_pages.write().await;
252
253            body_pages
254                .get_page(
255                    &self.client,
256                    &mut body_items,
257                    (),
258                    pagination,
259                    search,
260                    associated,
261                )
262                .await?
263        };
264        self.store_associated_entities(r.associated.clone()).await;
265        Ok(r)
266    }
267
268    async fn body_post(
269        &self,
270        new_body: Body,
271    ) -> Result<ItemResponse<(), BodyId, Body>, Self::ClientError> {
272        let r = {
273            let mut body_items = self.data.body_items.write().await;
274            let mut body_pages = self.data.body_pages.write().await;
275            let body_pages: &mut PageIndexCache<_, _, _> = &mut body_pages;
276
277            body_items
278                .create(&self.client, vec![body_pages], (), new_body)
279                .await?
280        };
281        self.store_associated_entities(r.associated.clone()).await;
282        Ok(r)
283    }
284
285    async fn body_by_id_or_alias_get(
286        &self,
287        body_id_or_alias: BodyIdOrAlias,
288        associated: Associated,
289    ) -> Result<ItemResponse<(), BodyId, Body>, Self::ClientError> {
290        let r = {
291            let mut body_items = self.data.body_items.write().await;
292            let mut body_aliases = self.data.body_aliases.write().await;
293
294            body_aliases
295                .get_by_alias(
296                    &self.client,
297                    (),
298                    body_id_or_alias,
299                    &mut body_items,
300                    associated,
301                )
302                .await?
303        };
304        self.store_associated_entities(r.associated.clone()).await;
305        Ok(r)
306    }
307
308    async fn body_by_id_or_alias_patch(
309        &self,
310        body_id_or_alias: BodyIdOrAlias,
311        update_body: UpdateBody,
312    ) -> Result<ItemResponse<(), BodyId, Body>, Self::ClientError> {
313        let r = {
314            let mut body_items = self.data.body_items.write().await;
315            let mut body_aliases = self.data.body_aliases.write().await;
316
317            body_aliases
318                .update_by_alias(
319                    &self.client,
320                    (),
321                    body_id_or_alias,
322                    update_body,
323                    &mut body_items,
324                )
325                .await?
326        };
327        self.store_associated_entities(r.associated.clone()).await;
328        Ok(r)
329    }
330
331    async fn body_by_id_or_alias_permission_get(
332        &self,
333        body_id: BodyId,
334        pagination: Pagination,
335        search: Search,
336        associated: Associated,
337    ) -> Result<PagedResponse<permission::ParentId, BodyPermissionId, Permission>, Self::ClientError>
338    {
339        let r = {
340            let mut body_permission_items = self.data.body_permission_items.write().await;
341            let mut body_permission_pages = self.data.body_permission_pages.write().await;
342
343            body_permission_pages
344                .get_page(
345                    &self.client,
346                    &mut body_permission_items,
347                    permission::ParentId { body_id },
348                    pagination,
349                    search,
350                    associated,
351                )
352                .await?
353        };
354        self.store_associated_entities(r.associated.clone()).await;
355        Ok(r)
356    }
357
358    async fn body_by_id_or_alias_permission_post(
359        &self,
360        body_id: BodyId,
361        new_permission: NewPermission,
362    ) -> Result<ItemResponse<permission::ParentId, BodyPermissionId, Permission>, Self::ClientError>
363    {
364        let r = {
365            let mut body_permission_items = self.data.body_permission_items.write().await;
366
367            let mut body_permission_pages = self.data.body_permission_pages.write().await;
368            let body_permission_pages: &mut PageIndexCache<_, _, _> = &mut body_permission_pages;
369
370            body_permission_items
371                .create(
372                    &self.client,
373                    vec![body_permission_pages],
374                    permission::ParentId { body_id },
375                    new_permission,
376                )
377                .await?
378        };
379        self.store_associated_entities(r.associated.clone()).await;
380        Ok(r)
381    }
382
383    async fn body_by_id_or_alias_permission_by_id_get(
384        &self,
385        body_id: BodyId,
386        permission_id: BodyPermissionId,
387        associated: Associated,
388    ) -> Result<ItemResponse<permission::ParentId, BodyPermissionId, Permission>, Self::ClientError>
389    {
390        let r = {
391            let mut body_permission_items = self.data.body_permission_items.write().await;
392            body_permission_items
393                .get(
394                    &self.client,
395                    permission::ParentId { body_id },
396                    permission_id,
397                    associated,
398                )
399                .await?
400        };
401        self.store_associated_entities(r.associated.clone()).await;
402        Ok(r)
403    }
404
405    async fn body_by_id_or_alias_meeting_get(
406        &self,
407        body_id: BodyId,
408        pagination: Pagination,
409        search: Search,
410        associated: Associated,
411    ) -> Result<PagedResponse<meeting::ParentId, MeetingId, Meeting>, Self::ClientError> {
412        let r = {
413            let mut meeting_items = self.data.meeting_items.write().await;
414            let mut meeting_pages = self.data.meeting_pages.write().await;
415
416            meeting_pages
417                .get_page(
418                    &self.client,
419                    &mut meeting_items,
420                    meeting::ParentId { body_id },
421                    pagination,
422                    search,
423                    associated,
424                )
425                .await?
426        };
427        self.store_associated_entities(r.associated.clone()).await;
428        Ok(r)
429    }
430
431    async fn body_by_id_or_alias_meeting_post(
432        &self,
433        body_id: BodyId,
434        new_meeting: EditableMeeting,
435    ) -> Result<ItemResponse<meeting::ParentId, MeetingId, Meeting>, Self::ClientError> {
436        let r = {
437            let mut meeting_items = self.data.meeting_items.write().await;
438            let mut meeting_pages = self.data.meeting_pages.write().await;
439            let meeting_pages: &mut PageIndexCache<_, _, _> = &mut meeting_pages;
440
441            meeting_items
442                .create(
443                    &self.client,
444                    vec![meeting_pages],
445                    meeting::ParentId { body_id },
446                    new_meeting,
447                )
448                .await?
449        };
450        self.store_associated_entities(r.associated.clone()).await;
451        Ok(r)
452    }
453
454    async fn body_by_id_or_alias_meeting_by_id_get(
455        &self,
456        body_id: BodyId,
457        meeting_id: MeetingId,
458        associated: Associated,
459    ) -> Result<ItemResponse<meeting::ParentId, MeetingId, Meeting>, Self::ClientError> {
460        let r = {
461            let mut meeting_items = self.data.meeting_items.write().await;
462
463            meeting_items
464                .get(
465                    &self.client,
466                    meeting::ParentId { body_id },
467                    meeting_id,
468                    associated,
469                )
470                .await?
471        };
472        self.store_associated_entities(r.associated.clone()).await;
473        Ok(r)
474    }
475
476    async fn body_by_id_or_alias_meeting_by_id_patch(
477        &self,
478        body_id: BodyId,
479        meeting_id: MeetingId,
480        update_meeting: UpdateMeeting,
481    ) -> Result<ItemResponse<meeting::ParentId, MeetingId, Meeting>, Self::ClientError> {
482        let r = {
483            let mut meeting_items = self.data.meeting_items.write().await;
484
485            let start_is_changed = update_meeting.start.is_some();
486
487            let updated_item = meeting_items
488                .update(
489                    &self.client,
490                    meeting::ParentId { body_id },
491                    meeting_id,
492                    update_meeting,
493                )
494                .await?;
495
496            if start_is_changed {
497                // if the `start` field is changed, the pages might require different ordering
498                let mut meeting_pages = self.data.meeting_pages.write().await;
499                meeting_pages.clear();
500            }
501            updated_item
502        };
503        self.store_associated_entities(r.associated.clone()).await;
504        Ok(r)
505    }
506
507    async fn body_by_id_or_alias_meeting_by_id_agenda_item_get(
508        &self,
509        body_id: BodyId,
510        meeting_id: MeetingId,
511        pagination: Pagination,
512        search: Search,
513        associated: Associated,
514    ) -> Result<PagedResponse<agenda_item::ParentId, AgendaItemId, AgendaItem>, Self::ClientError>
515    {
516        let r = {
517            let mut agenda_item_items = self.data.agenda_item_items.write().await;
518            let mut agenda_item_pages = self.data.agenda_item_pages.write().await;
519
520            agenda_item_pages
521                .get_page(
522                    &self.client,
523                    &mut agenda_item_items,
524                    agenda_item::ParentId {
525                        body_id,
526                        meeting_id,
527                    },
528                    pagination,
529                    search,
530                    associated,
531                )
532                .await?
533        };
534        self.store_associated_entities(r.associated.clone()).await;
535        Ok(r)
536    }
537
538    async fn body_by_id_or_alias_meeting_by_id_agenda_item_post(
539        &self,
540        body_id: BodyId,
541        meeting_id: MeetingId,
542        new_agenda_item: AgendaItem,
543    ) -> Result<ItemResponse<agenda_item::ParentId, AgendaItemId, AgendaItem>, Self::ClientError>
544    {
545        let r = {
546            let mut agenda_item_items = self.data.agenda_item_items.write().await;
547            let mut agenda_item_pages = self.data.agenda_item_pages.write().await;
548            let agenda_item_pages: &mut PageIndexCache<_, _, _> = &mut agenda_item_pages;
549
550            agenda_item_items
551                .create(
552                    &self.client,
553                    vec![agenda_item_pages],
554                    agenda_item::ParentId {
555                        body_id,
556                        meeting_id,
557                    },
558                    new_agenda_item,
559                )
560                .await?
561        };
562        self.store_associated_entities(r.associated.clone()).await;
563        Ok(r)
564    }
565
566    async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_get(
567        &self,
568        body_id: BodyId,
569        meeting_id: MeetingId,
570        agenda_item_id: AgendaItemId,
571        associated: Associated,
572    ) -> Result<ItemResponse<agenda_item::ParentId, AgendaItemId, AgendaItem>, Self::ClientError>
573    {
574        let r = {
575            let mut agenda_item_items = self.data.agenda_item_items.write().await;
576            agenda_item_items
577                .get(
578                    &self.client,
579                    agenda_item::ParentId {
580                        body_id,
581                        meeting_id,
582                    },
583                    agenda_item_id,
584                    associated,
585                )
586                .await?
587        };
588        self.store_associated_entities(r.associated.clone()).await;
589        Ok(r)
590    }
591
592    async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_patch(
593        &self,
594        body_id: BodyId,
595        meeting_id: MeetingId,
596        agenda_item_id: AgendaItemId,
597        update_agenda_item: UpdateAgendaItem,
598    ) -> Result<ItemResponse<agenda_item::ParentId, AgendaItemId, AgendaItem>, Self::ClientError>
599    {
600        let r = {
601            let mut agenda_item_items = self.data.agenda_item_items.write().await;
602
603            agenda_item_items
604                .update(
605                    &self.client,
606                    agenda_item::ParentId {
607                        body_id,
608                        meeting_id,
609                    },
610                    agenda_item_id,
611                    update_agenda_item,
612                )
613                .await?
614        };
615        self.store_associated_entities(r.associated.clone()).await;
616        Ok(r)
617    }
618
619    async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_consultation_get(
620        &self,
621        body_id: BodyId,
622        meeting_id: MeetingId,
623        agenda_item_id: AgendaItemId,
624        associated: Associated,
625    ) -> Result<ItemResponse<consultation::ParentId, AgendaItemId, Consultation>, Self::ClientError>
626    {
627        let r = {
628            let mut consultation_items = self.data.consultation_items.write().await;
629            consultation_items
630                .get(
631                    &self.client,
632                    consultation::ParentId {
633                        body_id,
634                        meeting_id,
635                    },
636                    agenda_item_id,
637                    associated,
638                )
639                .await?
640        };
641        self.store_associated_entities(r.associated.clone()).await;
642        Ok(r)
643    }
644
645    async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_consultation_put(
646        &self,
647        body_id: BodyId,
648        meeting_id: MeetingId,
649        agenda_item_id: AgendaItemId,
650        consultation: Consultation,
651    ) -> Result<ItemResponse<consultation::ParentId, AgendaItemId, Consultation>, Self::ClientError>
652    {
653        let r = {
654            let mut consultation_items = self.data.consultation_items.write().await;
655
656            consultation_items
657                .place(
658                    &self.client,
659                    vec![],
660                    consultation::ParentId {
661                        body_id,
662                        meeting_id,
663                    },
664                    agenda_item_id,
665                    consultation,
666                )
667                .await?
668        };
669        self.store_associated_entities(r.associated.clone()).await;
670        Ok(r)
671    }
672
673    async fn body_by_id_or_alias_meeting_by_id_agenda_item_by_id_consultation_patch(
674        &self,
675        body_id: BodyId,
676        meeting_id: MeetingId,
677        agenda_item_id: AgendaItemId,
678        update_consultation: UpdateConsultation,
679    ) -> Result<ItemResponse<consultation::ParentId, AgendaItemId, Consultation>, Self::ClientError>
680    {
681        let r = {
682            let mut consultation_items = self.data.consultation_items.write().await;
683
684            consultation_items
685                .update(
686                    &self.client,
687                    consultation::ParentId {
688                        body_id,
689                        meeting_id,
690                    },
691                    agenda_item_id,
692                    update_consultation,
693                )
694                .await?
695        };
696        self.store_associated_entities(r.associated.clone()).await;
697        Ok(r)
698    }
699
700    async fn body_by_id_or_alias_organization_get(
701        &self,
702        body_id: BodyId,
703        pagination: Pagination,
704        search: Search,
705        associated: Associated,
706    ) -> Result<
707        PagedResponse<organization::ParentId, OrganizationId, Organization>,
708        Self::ClientError,
709    > {
710        let r = {
711            let mut organization_items = self.data.organization_items.write().await;
712            let mut organization_pages = self.data.organization_pages.write().await;
713
714            organization_pages
715                .get_page(
716                    &self.client,
717                    &mut organization_items,
718                    organization::ParentId { body_id },
719                    pagination,
720                    search,
721                    associated,
722                )
723                .await?
724        };
725        self.store_associated_entities(r.associated.clone()).await;
726        Ok(r)
727    }
728
729    async fn body_by_id_or_alias_organization_post(
730        &self,
731        body_id: BodyId,
732        new_organization: NewOrganization,
733    ) -> Result<ItemResponse<organization::ParentId, OrganizationId, Organization>, Self::ClientError>
734    {
735        let r = {
736            let mut organization_items = self.data.organization_items.write().await;
737            let mut organization_pages = self.data.organization_pages.write().await;
738            let organization_pages: &mut PageIndexCache<_, _, _> = &mut organization_pages;
739
740            organization_items
741                .create(
742                    &self.client,
743                    vec![organization_pages],
744                    organization::ParentId { body_id },
745                    new_organization,
746                )
747                .await?
748        };
749        self.store_associated_entities(r.associated.clone()).await;
750        Ok(r)
751    }
752
753    async fn body_by_id_or_alias_organization_by_id_get(
754        &self,
755        body_id: BodyId,
756        organization_id: OrganizationId,
757        associated: Associated,
758    ) -> Result<ItemResponse<organization::ParentId, OrganizationId, Organization>, Self::ClientError>
759    {
760        let r = {
761            let mut organization_items = self.data.organization_items.write().await;
762
763            organization_items
764                .get(
765                    &self.client,
766                    organization::ParentId { body_id },
767                    organization_id,
768                    associated,
769                )
770                .await?
771        };
772        self.store_associated_entities(r.associated.clone()).await;
773        Ok(r)
774    }
775
776    async fn body_by_id_or_alias_organization_by_id_patch(
777        &self,
778        body_id: BodyId,
779        organization_id: OrganizationId,
780        update_organization: UpdateOrganization,
781    ) -> Result<ItemResponse<organization::ParentId, OrganizationId, Organization>, Self::ClientError>
782    {
783        let r = {
784            let mut organization_items = self.data.organization_items.write().await;
785
786            organization_items
787                .update(
788                    &self.client,
789                    organization::ParentId { body_id },
790                    organization_id,
791                    update_organization,
792                )
793                .await?
794        };
795        self.store_associated_entities(r.associated.clone()).await;
796        Ok(r)
797    }
798
799    async fn body_by_id_or_alias_organization_by_id_membership_get(
800        &self,
801        body_id: BodyId,
802        organization_id: OrganizationId,
803        pagination: Pagination,
804        search: Search,
805        associated: Associated,
806    ) -> Result<
807        PagedResponse<organization::by_id::membership::ParentId, MembershipId, Membership>,
808        Self::ClientError,
809    > {
810        let r = {
811            let mut membership_items = self.data.membership_items.write().await;
812            let mut membership_organization_pages =
813                self.data.membership_organization_pages.write().await;
814
815            membership_organization_pages
816                .get_page(
817                    &self.client,
818                    &mut membership_items,
819                    organization::by_id::membership::ParentId {
820                        body_id,
821                        organization_id,
822                    },
823                    pagination,
824                    search,
825                    associated,
826                )
827                .await?
828        };
829        self.store_associated_entities(r.associated.clone()).await;
830        Ok(r)
831    }
832
833    async fn body_by_id_or_alias_organization_by_id_membership_post(
834        &self,
835        body_id: BodyId,
836        organization_id: OrganizationId,
837        new_membership: organization::by_id::membership::NewMembership,
838    ) -> Result<
839        ItemResponse<organization::by_id::membership::ParentId, MembershipId, Membership>,
840        Self::ClientError,
841    > {
842        let r = {
843            let mut membership_items = self.data.membership_items.write().await;
844
845            let mut membership_pages = self.data.membership_pages.write().await;
846            let membership_pages: &mut PageIndexCache<_, _, _> = &mut membership_pages;
847
848            let mut membership_organization_pages =
849                self.data.membership_organization_pages.write().await;
850            let membership_organization_pages: &mut PageIndexCache<_, _, _> =
851                &mut membership_organization_pages;
852
853            let mut membership_person_pages = self.data.membership_person_pages.write().await;
854            let membership_person_pages: &mut PageIndexCache<_, _, _> =
855                &mut membership_person_pages;
856
857            membership_items
858                .create(
859                    &self.client,
860                    vec![
861                        membership_pages,
862                        membership_organization_pages,
863                        membership_person_pages,
864                    ],
865                    organization::by_id::membership::ParentId {
866                        body_id,
867                        organization_id,
868                    },
869                    new_membership,
870                )
871                .await?
872        };
873        self.store_associated_entities(r.associated.clone()).await;
874        Ok(r)
875    }
876
877    async fn body_by_id_or_alias_organization_by_id_membership_by_id_get(
878        &self,
879        body_id: BodyId,
880        organization_id: OrganizationId,
881        membership_id: MembershipId,
882        associated: Associated,
883    ) -> Result<
884        ItemResponse<organization::by_id::membership::ParentId, MembershipId, Membership>,
885        Self::ClientError,
886    > {
887        let r = {
888            let mut membership_items = self.data.membership_items.write().await;
889
890            membership_items
891                .get(
892                    &self.client,
893                    membership::ParentId { body_id },
894                    membership_id,
895                    associated,
896                )
897                .await?
898        };
899        self.store_associated_entities(r.associated.clone()).await;
900
901        // TODO: get by organization membership parent id
902        Ok(DataItem {
903            id: r.value.id,
904            parent_id: organization::by_id::membership::ParentId {
905                body_id,
906                organization_id,
907            },
908            metadata: r.value.metadata,
909            value: r.value.value,
910        }
911        .into())
912    }
913
914    async fn body_by_id_or_alias_organization_by_id_membership_by_id_patch(
915        &self,
916        body_id: BodyId,
917        organization_id: OrganizationId,
918        membership_id: MembershipId,
919        update_membership: UpdateMembership,
920    ) -> Result<
921        ItemResponse<organization::by_id::membership::ParentId, MembershipId, Membership>,
922        Self::ClientError,
923    > {
924        let r = {
925            let mut membership_items = self.data.membership_items.write().await;
926
927            membership_items
928                .update(
929                    &self.client,
930                    membership::ParentId { body_id },
931                    membership_id,
932                    update_membership,
933                )
934                .await?
935        };
936        self.store_associated_entities(r.associated.clone()).await;
937
938        // TODO: update by organization membership parent id
939        Ok(DataItem {
940            id: r.value.id,
941            parent_id: organization::by_id::membership::ParentId {
942                body_id,
943                organization_id,
944            },
945            metadata: r.value.metadata,
946            value: r.value.value,
947        }
948        .into())
949    }
950
951    async fn body_by_id_or_alias_person_get(
952        &self,
953        body_id: BodyId,
954        pagination: Pagination,
955        search: Search,
956        associated: Associated,
957    ) -> Result<PagedResponse<person::ParentId, PersonId, Person>, Self::ClientError> {
958        let r = {
959            let mut person_items = self.data.person_items.write().await;
960            let mut person_pages = self.data.person_pages.write().await;
961
962            person_pages
963                .get_page(
964                    &self.client,
965                    &mut person_items,
966                    person::ParentId { body_id },
967                    pagination,
968                    search,
969                    associated,
970                )
971                .await?
972        };
973        self.store_associated_entities(r.associated.clone()).await;
974        Ok(r)
975    }
976
977    async fn body_by_id_or_alias_person_post(
978        &self,
979        body_id: BodyId,
980        new_person: NewPerson,
981    ) -> Result<ItemResponse<person::ParentId, PersonId, Person>, Self::ClientError> {
982        let r = {
983            let mut person_items = self.data.person_items.write().await;
984            let mut person_pages = self.data.person_pages.write().await;
985            let person_pages: &mut PageIndexCache<_, _, _> = &mut person_pages;
986
987            person_items
988                .create(
989                    &self.client,
990                    vec![person_pages],
991                    person::ParentId { body_id },
992                    new_person,
993                )
994                .await?
995        };
996        self.store_associated_entities(r.associated.clone()).await;
997        Ok(r)
998    }
999
1000    async fn body_by_id_or_alias_person_by_id_get(
1001        &self,
1002        body_id: BodyId,
1003        person_id: PersonId,
1004        associated: Associated,
1005    ) -> Result<ItemResponse<person::ParentId, PersonId, Person>, Self::ClientError> {
1006        let r = {
1007            let mut person_items = self.data.person_items.write().await;
1008            person_items
1009                .get(
1010                    &self.client,
1011                    person::ParentId { body_id },
1012                    person_id,
1013                    associated,
1014                )
1015                .await?
1016        };
1017        self.store_associated_entities(r.associated.clone()).await;
1018        Ok(r)
1019    }
1020
1021    async fn body_by_id_or_alias_person_by_id_patch(
1022        &self,
1023        body_id: BodyId,
1024        person_id: PersonId,
1025        update_person: UpdatePerson,
1026    ) -> Result<ItemResponse<person::ParentId, PersonId, Person>, Self::ClientError> {
1027        let r = {
1028            let mut person_items = self.data.person_items.write().await;
1029
1030            person_items
1031                .update(
1032                    &self.client,
1033                    person::ParentId { body_id },
1034                    person_id,
1035                    update_person,
1036                )
1037                .await?
1038        };
1039        self.store_associated_entities(r.associated.clone()).await;
1040        Ok(r)
1041    }
1042
1043    async fn body_by_id_or_alias_person_by_id_membership_get(
1044        &self,
1045        body_id: BodyId,
1046        person_id: PersonId,
1047        pagination: Pagination,
1048        search: Search,
1049        associated: Associated,
1050    ) -> Result<
1051        PagedResponse<person::by_id::membership::ParentId, MembershipId, Membership>,
1052        Self::ClientError,
1053    > {
1054        let r = {
1055            let mut membership_items = self.data.membership_items.write().await;
1056            let mut membership_person_pages = self.data.membership_person_pages.write().await;
1057
1058            membership_person_pages
1059                .get_page(
1060                    &self.client,
1061                    &mut membership_items,
1062                    person::by_id::membership::ParentId { body_id, person_id },
1063                    pagination,
1064                    search,
1065                    associated,
1066                )
1067                .await?
1068        };
1069        self.store_associated_entities(r.associated.clone()).await;
1070        Ok(r)
1071    }
1072
1073    async fn body_by_id_or_alias_person_by_id_membership_post(
1074        &self,
1075        body_id: BodyId,
1076        person_id: PersonId,
1077        new_membership: person::by_id::membership::NewMembership,
1078    ) -> Result<
1079        ItemResponse<person::by_id::membership::ParentId, MembershipId, Membership>,
1080        Self::ClientError,
1081    > {
1082        let r = {
1083            let mut membership_items = self.data.membership_items.write().await;
1084
1085            let mut membership_pages = self.data.membership_pages.write().await;
1086            let membership_pages: &mut PageIndexCache<_, _, _> = &mut membership_pages;
1087
1088            let mut membership_organization_pages =
1089                self.data.membership_organization_pages.write().await;
1090            let membership_organization_pages: &mut PageIndexCache<_, _, _> =
1091                &mut membership_organization_pages;
1092
1093            let mut membership_person_pages = self.data.membership_person_pages.write().await;
1094            let membership_person_pages: &mut PageIndexCache<_, _, _> =
1095                &mut membership_person_pages;
1096
1097            membership_items
1098                .create(
1099                    &self.client,
1100                    vec![
1101                        membership_pages,
1102                        membership_organization_pages,
1103                        membership_person_pages,
1104                    ],
1105                    person::by_id::membership::ParentId { body_id, person_id },
1106                    new_membership,
1107                )
1108                .await?
1109        };
1110        self.store_associated_entities(r.associated.clone()).await;
1111        Ok(r)
1112    }
1113
1114    async fn body_by_id_or_alias_person_by_id_membership_by_id_get(
1115        &self,
1116        body_id: BodyId,
1117        person_id: PersonId,
1118        membership_id: MembershipId,
1119        associated: Associated,
1120    ) -> Result<
1121        ItemResponse<person::by_id::membership::ParentId, MembershipId, Membership>,
1122        Self::ClientError,
1123    > {
1124        let r = {
1125            let mut membership_items = self.data.membership_items.write().await;
1126            membership_items
1127                .get(
1128                    &self.client,
1129                    membership::ParentId { body_id },
1130                    membership_id,
1131                    associated,
1132                )
1133                .await?
1134        };
1135        self.store_associated_entities(r.associated.clone()).await;
1136
1137        // TODO: get by person membership parent id
1138        Ok(DataItem {
1139            id: r.value.id,
1140            parent_id: person::by_id::membership::ParentId { body_id, person_id },
1141            metadata: r.value.metadata,
1142            value: r.value.value,
1143        }
1144        .into())
1145    }
1146
1147    async fn body_by_id_or_alias_person_by_id_membership_by_id_patch(
1148        &self,
1149        body_id: BodyId,
1150        person_id: PersonId,
1151        membership_id: MembershipId,
1152        update_membership: UpdateMembership,
1153    ) -> Result<
1154        ItemResponse<person::by_id::membership::ParentId, MembershipId, Membership>,
1155        Self::ClientError,
1156    > {
1157        let r = {
1158            let mut membership_items = self.data.membership_items.write().await;
1159
1160            membership_items
1161                .update(
1162                    &self.client,
1163                    membership::ParentId { body_id },
1164                    membership_id,
1165                    update_membership,
1166                )
1167                .await?
1168        };
1169        self.store_associated_entities(r.associated.clone()).await;
1170
1171        // TODO: get by person membership parent id
1172        Ok(DataItem {
1173            id: r.value.id,
1174            parent_id: person::by_id::membership::ParentId { body_id, person_id },
1175            metadata: r.value.metadata,
1176            value: r.value.value,
1177        }
1178        .into())
1179    }
1180
1181    async fn body_by_id_or_alias_membership_get(
1182        &self,
1183        body_id: BodyId,
1184        pagination: Pagination,
1185        search: Search,
1186        associated: Associated,
1187    ) -> Result<PagedResponse<membership::ParentId, MembershipId, Membership>, Self::ClientError>
1188    {
1189        let r = {
1190            let mut membership_items = self.data.membership_items.write().await;
1191            let mut membership_pages = self.data.membership_pages.write().await;
1192
1193            membership_pages
1194                .get_page(
1195                    &self.client,
1196                    &mut membership_items,
1197                    membership::ParentId { body_id },
1198                    pagination,
1199                    search,
1200                    associated,
1201                )
1202                .await?
1203        };
1204        self.store_associated_entities(r.associated.clone()).await;
1205        Ok(r)
1206    }
1207
1208    async fn body_by_id_or_alias_membership_post(
1209        &self,
1210        body_id: BodyId,
1211        new_membership: Membership,
1212    ) -> Result<ItemResponse<membership::ParentId, MembershipId, Membership>, Self::ClientError>
1213    {
1214        let r = {
1215            let mut membership_items = self.data.membership_items.write().await;
1216
1217            let mut membership_pages = self.data.membership_pages.write().await;
1218            let membership_pages: &mut PageIndexCache<_, _, _> = &mut membership_pages;
1219
1220            let mut membership_organization_pages = self.data.membership_pages.write().await;
1221            let membership_organization_pages: &mut PageIndexCache<_, _, _> =
1222                &mut membership_organization_pages;
1223
1224            let mut membership_person_pages = self.data.membership_pages.write().await;
1225            let membership_person_pages: &mut PageIndexCache<_, _, _> =
1226                &mut membership_person_pages;
1227
1228            membership_items
1229                .create(
1230                    &self.client,
1231                    vec![
1232                        membership_pages,
1233                        membership_organization_pages,
1234                        membership_person_pages,
1235                    ],
1236                    membership::ParentId { body_id },
1237                    new_membership,
1238                )
1239                .await?
1240        };
1241        self.store_associated_entities(r.associated.clone()).await;
1242        Ok(r)
1243    }
1244
1245    async fn body_by_id_or_alias_membership_by_id_get(
1246        &self,
1247        body_id: BodyId,
1248        membership_id: MembershipId,
1249        associated: Associated,
1250    ) -> Result<ItemResponse<membership::ParentId, MembershipId, Membership>, Self::ClientError>
1251    {
1252        let r = {
1253            let mut membership_items = self.data.membership_items.write().await;
1254            membership_items
1255                .get(
1256                    &self.client,
1257                    membership::ParentId { body_id },
1258                    membership_id,
1259                    associated,
1260                )
1261                .await?
1262        };
1263        self.store_associated_entities(r.associated.clone()).await;
1264        Ok(r)
1265    }
1266
1267    async fn body_by_id_or_alias_membership_by_id_patch(
1268        &self,
1269        body_id: BodyId,
1270        membership_id: MembershipId,
1271        update_membership: UpdateMembership,
1272    ) -> Result<ItemResponse<membership::ParentId, MembershipId, Membership>, Self::ClientError>
1273    {
1274        let r = {
1275            let mut membership_items = self.data.membership_items.write().await;
1276
1277            membership_items
1278                .update(
1279                    &self.client,
1280                    membership::ParentId { body_id },
1281                    membership_id,
1282                    update_membership,
1283                )
1284                .await?
1285        };
1286        self.store_associated_entities(r.associated.clone()).await;
1287        Ok(r)
1288    }
1289
1290    async fn body_by_id_or_alias_location_get(
1291        &self,
1292        body_id: BodyId,
1293        pagination: Pagination,
1294        search: Search,
1295        associated: Associated,
1296    ) -> Result<PagedResponse<location::ParentId, LocationId, Location>, Self::ClientError> {
1297        let r = {
1298            let mut location_items = self.data.location_items.write().await;
1299            let mut location_pages = self.data.location_pages.write().await;
1300
1301            location_pages
1302                .get_page(
1303                    &self.client,
1304                    &mut location_items,
1305                    location::ParentId { body_id },
1306                    pagination,
1307                    search,
1308                    associated,
1309                )
1310                .await?
1311        };
1312        self.store_associated_entities(r.associated.clone()).await;
1313        Ok(r)
1314    }
1315
1316    async fn body_by_id_or_alias_location_post(
1317        &self,
1318        body_id: BodyId,
1319        new_location: NewLocation,
1320    ) -> Result<ItemResponse<location::ParentId, LocationId, Location>, Self::ClientError> {
1321        let r = {
1322            let mut location_items = self.data.location_items.write().await;
1323
1324            let mut location_pages = self.data.location_pages.write().await;
1325            let location_pages: &mut PageIndexCache<_, _, _> = &mut location_pages;
1326
1327            location_items
1328                .create(
1329                    &self.client,
1330                    vec![location_pages],
1331                    location::ParentId { body_id },
1332                    new_location,
1333                )
1334                .await?
1335        };
1336        self.store_associated_entities(r.associated.clone()).await;
1337        Ok(r)
1338    }
1339
1340    async fn body_by_id_or_alias_location_by_id_get(
1341        &self,
1342        body_id: BodyId,
1343        location_id: LocationId,
1344        associated: Associated,
1345    ) -> Result<ItemResponse<location::ParentId, LocationId, Location>, Self::ClientError> {
1346        let r = {
1347            let mut location_items = self.data.location_items.write().await;
1348            location_items
1349                .get(
1350                    &self.client,
1351                    location::ParentId { body_id },
1352                    location_id,
1353                    associated,
1354                )
1355                .await?
1356        };
1357        self.store_associated_entities(r.associated.clone()).await;
1358        Ok(r)
1359    }
1360
1361    async fn body_by_id_or_alias_location_by_id_patch(
1362        &self,
1363        body_id: BodyId,
1364        location_id: LocationId,
1365        update_location: UpdateLocation,
1366    ) -> Result<ItemResponse<location::ParentId, LocationId, Location>, Self::ClientError> {
1367        let r = {
1368            let mut location_items = self.data.location_items.write().await;
1369
1370            location_items
1371                .update(
1372                    &self.client,
1373                    location::ParentId { body_id },
1374                    location_id,
1375                    update_location,
1376                )
1377                .await?
1378        };
1379        self.store_associated_entities(r.associated.clone()).await;
1380        Ok(r)
1381    }
1382
1383    async fn body_by_id_or_alias_paper_get(
1384        &self,
1385        body_id: BodyId,
1386        pagination: Pagination,
1387        search: Search,
1388        associated: Associated,
1389    ) -> Result<PagedResponse<paper::ParentId, PaperId, Paper>, Self::ClientError> {
1390        let r = {
1391            let mut paper_items = self.data.paper_items.write().await;
1392            let mut paper_pages = self.data.paper_pages.write().await;
1393
1394            paper_pages
1395                .get_page(
1396                    &self.client,
1397                    &mut paper_items,
1398                    paper::ParentId { body_id },
1399                    pagination,
1400                    search,
1401                    associated,
1402                )
1403                .await?
1404        };
1405        self.store_associated_entities(r.associated.clone()).await;
1406        Ok(r)
1407    }
1408
1409    async fn body_by_id_or_alias_paper_post(
1410        &self,
1411        body_id: BodyId,
1412        new_paper: NewPaper,
1413    ) -> Result<ItemResponse<paper::ParentId, PaperId, Paper>, Self::ClientError> {
1414        let r = {
1415            let mut paper_items = self.data.paper_items.write().await;
1416
1417            let mut paper_pages = self.data.paper_pages.write().await;
1418            let paper_pages: &mut PageIndexCache<_, _, _> = &mut paper_pages;
1419
1420            paper_items
1421                .create(
1422                    &self.client,
1423                    vec![paper_pages],
1424                    paper::ParentId { body_id },
1425                    new_paper,
1426                )
1427                .await?
1428        };
1429        self.store_associated_entities(r.associated.clone()).await;
1430        Ok(r)
1431    }
1432
1433    async fn body_by_id_or_alias_paper_by_id_get(
1434        &self,
1435        body_id: BodyId,
1436        paper_id: PaperId,
1437        associated: Associated,
1438    ) -> Result<ItemResponse<paper::ParentId, PaperId, Paper>, Self::ClientError> {
1439        let r = {
1440            let mut paper_items = self.data.paper_items.write().await;
1441            paper_items
1442                .get(
1443                    &self.client,
1444                    paper::ParentId { body_id },
1445                    paper_id,
1446                    associated,
1447                )
1448                .await?
1449        };
1450        self.store_associated_entities(r.associated.clone()).await;
1451        Ok(r)
1452    }
1453
1454    async fn body_by_id_or_alias_paper_by_id_patch(
1455        &self,
1456        body_id: BodyId,
1457        paper_id: PaperId,
1458        update_paper: UpdatePaper,
1459    ) -> Result<ItemResponse<paper::ParentId, PaperId, Paper>, Self::ClientError> {
1460        let r = {
1461            let mut paper_items = self.data.paper_items.write().await;
1462
1463            paper_items
1464                .update(
1465                    &self.client,
1466                    paper::ParentId { body_id },
1467                    paper_id,
1468                    update_paper,
1469                )
1470                .await?
1471        };
1472        self.store_associated_entities(r.associated.clone()).await;
1473        Ok(r)
1474    }
1475
1476    async fn body_by_id_or_alias_location_by_id_paper_get(
1477        &self,
1478        body_id: BodyId,
1479        location_id: LocationId,
1480        pagination: Pagination,
1481        search: Search,
1482        associated: Associated,
1483    ) -> Result<
1484        PagedResponse<
1485            location::by_id::paper::ParentId,
1486            PaperLocationId,
1487            paper_location::PaperLocation,
1488        >,
1489        Self::ClientError,
1490    > {
1491        let r = {
1492            self.client
1493                .body_by_id_or_alias_location_by_id_paper_get(
1494                    body_id,
1495                    location_id,
1496                    pagination,
1497                    search,
1498                    associated,
1499                )
1500                .await?
1501        };
1502        self.store_associated_entities(r.associated.clone()).await;
1503        Ok(r)
1504    }
1505
1506    async fn body_by_id_or_alias_location_by_id_paper_post(
1507        &self,
1508        body_id: BodyId,
1509        location_id: LocationId,
1510        new_paper: location::by_id::paper::NewPaperLocation,
1511    ) -> Result<
1512        ItemResponse<
1513            location::by_id::paper::ParentId,
1514            PaperLocationId,
1515            paper_location::PaperLocation,
1516        >,
1517        Self::ClientError,
1518    > {
1519        let r = {
1520            self.client
1521                .body_by_id_or_alias_location_by_id_paper_post(body_id, location_id, new_paper)
1522                .await?
1523        };
1524        self.store_associated_entities(r.associated.clone()).await;
1525        Ok(r)
1526    }
1527
1528    async fn body_by_id_or_alias_location_by_id_paper_by_id_get(
1529        &self,
1530        body_id: BodyId,
1531        location_id: LocationId,
1532        paper_location_id: PaperLocationId,
1533        associated: Associated,
1534    ) -> Result<
1535        ItemResponse<
1536            location::by_id::paper::ParentId,
1537            PaperLocationId,
1538            paper_location::PaperLocation,
1539        >,
1540        Self::ClientError,
1541    > {
1542        let r = {
1543            self.client
1544                .body_by_id_or_alias_location_by_id_paper_by_id_get(
1545                    body_id,
1546                    location_id,
1547                    paper_location_id,
1548                    associated,
1549                )
1550                .await?
1551        };
1552        self.store_associated_entities(r.associated.clone()).await;
1553        Ok(r)
1554    }
1555
1556    async fn body_by_id_or_alias_location_by_id_paper_by_id_delete(
1557        &self,
1558        body_id: BodyId,
1559        location_id: LocationId,
1560        paper_location_id: PaperLocationId,
1561    ) -> Result<(), Self::ClientError> {
1562        self.client
1563            .body_by_id_or_alias_location_by_id_paper_by_id_delete(
1564                body_id,
1565                location_id,
1566                paper_location_id,
1567            )
1568            .await
1569    }
1570
1571    async fn body_by_id_or_alias_paper_by_id_location_get(
1572        &self,
1573        body_id: BodyId,
1574        paper_id: PaperId,
1575        pagination: Pagination,
1576        search: Search,
1577        associated: Associated,
1578    ) -> Result<
1579        PagedResponse<
1580            paper::by_id::location::ParentId,
1581            PaperLocationId,
1582            paper_location::PaperLocation,
1583        >,
1584        Self::ClientError,
1585    > {
1586        let r = {
1587            self.client
1588                .body_by_id_or_alias_paper_by_id_location_get(
1589                    body_id, paper_id, pagination, search, associated,
1590                )
1591                .await?
1592        };
1593        self.store_associated_entities(r.associated.clone()).await;
1594        Ok(r)
1595    }
1596
1597    async fn body_by_id_or_alias_paper_by_id_location_post(
1598        &self,
1599        body_id: BodyId,
1600        paper_id: PaperId,
1601        new_location: paper::by_id::location::NewPaperLocation,
1602    ) -> Result<
1603        ItemResponse<
1604            paper::by_id::location::ParentId,
1605            PaperLocationId,
1606            paper_location::PaperLocation,
1607        >,
1608        Self::ClientError,
1609    > {
1610        let r = {
1611            self.client
1612                .body_by_id_or_alias_paper_by_id_location_post(body_id, paper_id, new_location)
1613                .await?
1614        };
1615        self.store_associated_entities(r.associated.clone()).await;
1616        Ok(r)
1617    }
1618
1619    async fn body_by_id_or_alias_paper_by_id_location_by_id_get(
1620        &self,
1621        body_id: BodyId,
1622        paper_id: PaperId,
1623        paper_location_id: PaperLocationId,
1624        associated: Associated,
1625    ) -> Result<
1626        ItemResponse<
1627            paper::by_id::location::ParentId,
1628            PaperLocationId,
1629            paper_location::PaperLocation,
1630        >,
1631        Self::ClientError,
1632    > {
1633        let r = {
1634            self.client
1635                .body_by_id_or_alias_paper_by_id_location_by_id_get(
1636                    body_id,
1637                    paper_id,
1638                    paper_location_id,
1639                    associated,
1640                )
1641                .await?
1642        };
1643        self.store_associated_entities(r.associated.clone()).await;
1644        Ok(r)
1645    }
1646
1647    async fn body_by_id_or_alias_paper_by_id_location_by_id_delete(
1648        &self,
1649        body_id: BodyId,
1650        paper_id: PaperId,
1651        paper_location_id: PaperLocationId,
1652    ) -> Result<(), Self::ClientError> {
1653        self.client
1654            .body_by_id_or_alias_paper_by_id_location_by_id_delete(
1655                body_id,
1656                paper_id,
1657                paper_location_id,
1658            )
1659            .await
1660    }
1661
1662    async fn me_profile_get(&self) -> Result<Profile, Self::ClientError> {
1663        {
1664            let profile = self.data.profile.read().await;
1665            if let Some(profile) = &*profile {
1666                return Ok(profile.clone());
1667            }
1668        }
1669
1670        let mut lock = self.data.profile.write().await;
1671        let profile = self.client.me_profile_get().await?;
1672        _ = lock.insert(profile.clone());
1673        Ok(profile)
1674    }
1675
1676    async fn me_profile_patch(
1677        &self,
1678        update_profile: UpdateProfile,
1679    ) -> Result<Profile, Self::ClientError> {
1680        let profile = self.client.me_profile_patch(update_profile).await?;
1681
1682        let mut lock = self.data.profile.write().await;
1683        _ = lock.insert(profile.clone());
1684        Ok(profile)
1685    }
1686}
1687
1688impl CachedData {
1689    fn new() -> Self {
1690        let profile = Rc::new(RwLock::new(None));
1691
1692        let body_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1693        let body_items = Rc::new(RwLock::new(ItemCache::new()));
1694        let body_aliases = Rc::new(RwLock::new(AliasCache::new()));
1695
1696        let user_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1697        let user_items = Rc::new(RwLock::new(ItemCache::new()));
1698
1699        let meeting_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1700        let meeting_items = Rc::new(RwLock::new(ItemCache::new()));
1701
1702        let agenda_item_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1703        let agenda_item_items = Rc::new(RwLock::new(ItemCache::new()));
1704
1705        let consultation_items = Rc::new(RwLock::new(ItemCache::new()));
1706
1707        let organization_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1708        let organization_items = Rc::new(RwLock::new(ItemCache::new()));
1709
1710        let person_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1711        let person_items = Rc::new(RwLock::new(ItemCache::new()));
1712
1713        let membership_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1714        let membership_organization_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1715        let membership_person_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1716        let membership_items = Rc::new(RwLock::new(ItemCache::new()));
1717
1718        let body_permission_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1719        let body_permission_items = Rc::new(RwLock::new(ItemCache::new()));
1720
1721        let location_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1722        let location_items = Rc::new(RwLock::new(ItemCache::new()));
1723
1724        let paper_pages = Rc::new(RwLock::new(PageIndexCache::new()));
1725        let paper_items = Rc::new(RwLock::new(ItemCache::new()));
1726
1727        let paper_location_items = Rc::new(RwLock::new(ItemCache::new()));
1728
1729        Self {
1730            profile,
1731
1732            body_pages,
1733            body_items,
1734            body_aliases,
1735            user_pages,
1736            user_items,
1737            meeting_pages,
1738            meeting_items,
1739            agenda_item_pages,
1740            agenda_item_items,
1741            consultation_items,
1742            organization_pages,
1743            organization_items,
1744            person_pages,
1745            person_items,
1746            membership_pages,
1747            membership_organization_pages,
1748            membership_person_pages,
1749            membership_items,
1750            body_permission_pages,
1751            body_permission_items,
1752            location_pages,
1753            location_items,
1754            paper_pages,
1755            paper_items,
1756            paper_location_items,
1757        }
1758    }
1759}
1760
1761trait ClearableCache {
1762    fn clear_cache(&mut self);
1763}