1mod 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 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 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 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 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 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}