1#![allow(clippy::all, deprecated)]
7
8use crate::client::Query;
9use crate::query::ToQuery;
10
11#[derive(Debug, Clone, Default)]
13pub struct GetAddressesSearchQuery {
14 pub query: Option<String>,
16}
17
18impl GetAddressesSearchQuery {
19 pub(crate) fn to_query(&self) -> Query {
20 let mut q = Query::new();
21 self.query.push_query("query", &mut q);
22 q
23 }
24}
25
26#[derive(Debug, Clone, Default)]
28pub struct DeleteAgendatemplatesAgendaIdQuery {
29 #[deprecated = "deprecated in the ChurchTools API"]
31 pub dry_run: Option<bool>,
32}
33
34impl DeleteAgendatemplatesAgendaIdQuery {
35 pub(crate) fn to_query(&self) -> Query {
36 let mut q = Query::new();
37 self.dry_run.push_query("dryRun", &mut q);
38 q
39 }
40}
41
42#[derive(Debug, Clone, Default)]
44pub struct PostAgendatemplatesAgendaIdExportQuery {
45 pub format: Option<String>,
48}
49
50impl PostAgendatemplatesAgendaIdExportQuery {
51 pub(crate) fn to_query(&self) -> Query {
52 let mut q = Query::new();
53 self.format.push_query("format", &mut q);
54 q
55 }
56}
57
58#[derive(Debug, Clone, Default)]
60pub struct PostAgendatemplatesAgendaIdItemsQuery {
61 pub before_id: Option<i64>,
63 pub after_id: Option<i64>,
65 #[deprecated = "Use `before_id` or `after_id` to position an item."]
67 pub sort_key: Option<i64>,
68}
69
70impl PostAgendatemplatesAgendaIdItemsQuery {
71 pub(crate) fn to_query(&self) -> Query {
72 let mut q = Query::new();
73 self.before_id.push_query("before_id", &mut q);
74 self.after_id.push_query("after_id", &mut q);
75 self.sort_key.push_query("sortKey", &mut q);
76 q
77 }
78}
79
80#[derive(Debug, Clone, Default)]
82pub struct PutAgendatemplatesAgendaIdItemsItemIdQuery {
83 pub before_id: Option<i64>,
85 pub after_id: Option<i64>,
87 #[deprecated = "Use `before_id` or `after_id` to position an item."]
89 pub sort_key: Option<i64>,
90}
91
92impl PutAgendatemplatesAgendaIdItemsItemIdQuery {
93 pub(crate) fn to_query(&self) -> Query {
94 let mut q = Query::new();
95 self.before_id.push_query("before_id", &mut q);
96 self.after_id.push_query("after_id", &mut q);
97 self.sort_key.push_query("sortKey", &mut q);
98 q
99 }
100}
101
102#[derive(Debug, Clone, Default)]
104pub struct GetBookingsIdQuery {
105 pub include: Option<Vec<String>>,
108}
109
110impl GetBookingsIdQuery {
111 pub(crate) fn to_query(&self) -> Query {
112 let mut q = Query::new();
113 self.include.push_query("include[]", &mut q);
114 q
115 }
116}
117
118#[derive(Debug, Clone, Default)]
120pub struct GetBookingsQuery {
121 pub include: Option<Vec<String>>,
124 pub resource_ids: Option<Vec<i64>>,
126 pub query: Option<String>,
128 pub person_id: Option<i64>,
130 pub status_ids: Option<Vec<i64>>,
133 pub from: Option<chrono::NaiveDate>,
135 pub to: Option<chrono::NaiveDate>,
137}
138
139impl GetBookingsQuery {
140 pub(crate) fn to_query(&self) -> Query {
141 let mut q = Query::new();
142 self.include.push_query("include[]", &mut q);
143 self.resource_ids.push_query("resource_ids[]", &mut q);
144 self.query.push_query("query", &mut q);
145 self.person_id.push_query("person_id", &mut q);
146 self.status_ids.push_query("status_ids[]", &mut q);
147 self.from.push_query("from", &mut q);
148 self.to.push_query("to", &mut q);
149 q
150 }
151}
152
153#[derive(Debug, Clone, Default)]
155pub struct GetCalendarsCalendarIdMeetingrequestpersonsQuery {
156 pub appointment_id: Option<i64>,
158}
159
160impl GetCalendarsCalendarIdMeetingrequestpersonsQuery {
161 pub(crate) fn to_query(&self) -> Query {
162 let mut q = Query::new();
163 self.appointment_id.push_query("appointmentId", &mut q);
164 q
165 }
166}
167
168#[derive(Debug, Clone, Default)]
170pub struct GetCalendarsCalendarIdAppointmentsAppointmentIdQuery {
171 pub include: Option<Vec<String>>,
174}
175
176impl GetCalendarsCalendarIdAppointmentsAppointmentIdQuery {
177 pub(crate) fn to_query(&self) -> Query {
178 let mut q = Query::new();
179 self.include.push_query("include[]", &mut q);
180 q
181 }
182}
183
184#[derive(Debug, Clone, Default)]
186pub struct GetCalendarsAppointmentsAppointmentIdStartDateQuery {
187 pub include: Option<Vec<String>>,
190}
191
192impl GetCalendarsAppointmentsAppointmentIdStartDateQuery {
193 pub(crate) fn to_query(&self) -> Query {
194 let mut q = Query::new();
195 self.include.push_query("include[]", &mut q);
196 q
197 }
198}
199
200#[derive(Debug, Clone, Default)]
202pub struct GetCalendarsCalendarIdAppointmentsAppointmentIdStartDateQuery {
203 pub include: Option<Vec<String>>,
206}
207
208impl GetCalendarsCalendarIdAppointmentsAppointmentIdStartDateQuery {
209 pub(crate) fn to_query(&self) -> Query {
210 let mut q = Query::new();
211 self.include.push_query("include[]", &mut q);
212 q
213 }
214}
215
216#[derive(Debug, Clone, Default)]
218pub struct GetCalendarsAppointmentsQuery {
219 pub calendar_ids: Option<Vec<i64>>,
221 pub from: Option<chrono::NaiveDate>,
223 pub to: Option<chrono::NaiveDate>,
225 pub query: Option<String>,
227 pub include: Option<Vec<String>>,
230}
231
232impl GetCalendarsAppointmentsQuery {
233 pub(crate) fn to_query(&self) -> Query {
234 let mut q = Query::new();
235 self.calendar_ids.push_query("calendar_ids[]", &mut q);
236 self.from.push_query("from", &mut q);
237 self.to.push_query("to", &mut q);
238 self.query.push_query("query", &mut q);
239 self.include.push_query("include[]", &mut q);
240 q
241 }
242}
243
244#[derive(Debug, Clone, Default)]
246pub struct GetCalendarsCalendarIdAppointmentsQuery {
247 pub from: Option<chrono::NaiveDate>,
249 pub to: Option<chrono::NaiveDate>,
251 pub query: Option<String>,
253 pub include: Option<Vec<String>>,
256}
257
258impl GetCalendarsCalendarIdAppointmentsQuery {
259 pub(crate) fn to_query(&self) -> Query {
260 let mut q = Query::new();
261 self.from.push_query("from", &mut q);
262 self.to.push_query("to", &mut q);
263 self.query.push_query("query", &mut q);
264 self.include.push_query("include[]", &mut q);
265 q
266 }
267}
268
269#[derive(Debug, Clone, Default)]
271pub struct GetCalendarsCalendarIdMeetingrequestCandidatesQuery {
272 pub appointment_id: Option<i64>,
274}
275
276impl GetCalendarsCalendarIdMeetingrequestCandidatesQuery {
277 pub(crate) fn to_query(&self) -> Query {
278 let mut q = Query::new();
279 self.appointment_id.push_query("appointmentId", &mut q);
280 q
281 }
282}
283
284#[derive(Debug, Clone, Default)]
286pub struct DeleteChatGuidQuery {
287 pub nonce: Option<String>,
289}
290
291impl DeleteChatGuidQuery {
292 pub(crate) fn to_query(&self) -> Query {
293 let mut q = Query::new();
294 self.nonce.push_query("nonce", &mut q);
295 q
296 }
297}
298
299#[derive(Debug, Clone, Default)]
301pub struct GetChatQuery {
302 pub nonce: Option<String>,
304}
305
306impl GetChatQuery {
307 pub(crate) fn to_query(&self) -> Query {
308 let mut q = Query::new();
309 self.nonce.push_query("nonce", &mut q);
310 q
311 }
312}
313
314#[derive(Debug, Clone, Default)]
316pub struct PostCheckinPersonsQuery {
317 pub without_privacy_policy_agreement: Option<bool>,
319}
320
321impl PostCheckinPersonsQuery {
322 pub(crate) fn to_query(&self) -> Query {
323 let mut q = Query::new();
324 self.without_privacy_policy_agreement.push_query("without_privacy_policy_agreement", &mut q);
325 q
326 }
327}
328
329#[derive(Debug, Clone, Default)]
331pub struct GetChurchqueryMetadataQuery {
332 pub entity_to_search_for: Option<String>,
334 pub exclude_field_types: Option<Vec<String>>,
336}
337
338impl GetChurchqueryMetadataQuery {
339 pub(crate) fn to_query(&self) -> Query {
340 let mut q = Query::new();
341 self.entity_to_search_for.push_query("entity_to_search_for", &mut q);
342 self.exclude_field_types.push_query("exclude_field_types[]", &mut q);
343 q
344 }
345}
346
347#[derive(Debug, Clone, Default)]
349pub struct PostChurchqueryDebugExportQuery {
350 pub r#type: Option<String>,
352}
353
354impl PostChurchqueryDebugExportQuery {
355 pub(crate) fn to_query(&self) -> Query {
356 let mut q = Query::new();
357 self.r#type.push_query("type", &mut q);
358 q
359 }
360}
361
362#[derive(Debug, Clone, Default)]
364pub struct GetConfigQuery {
365 pub extended: Option<bool>,
367}
368
369impl GetConfigQuery {
370 pub(crate) fn to_query(&self) -> Query {
371 let mut q = Query::new();
372 self.extended.push_query("extended", &mut q);
373 q
374 }
375}
376
377#[derive(Debug, Clone, Default)]
379pub struct DeleteContactlabelsIdQuery {
380 pub dry_run: Option<bool>,
382}
383
384impl DeleteContactlabelsIdQuery {
385 pub(crate) fn to_query(&self) -> Query {
386 let mut q = Query::new();
387 self.dry_run.push_query("dry_run", &mut q);
388 q
389 }
390}
391
392#[derive(Debug, Clone, Default)]
394pub struct GetDbfieldsQuery {
395 pub categories: Option<Vec<String>>,
398 pub include: Option<Vec<String>>,
401}
402
403impl GetDbfieldsQuery {
404 pub(crate) fn to_query(&self) -> Query {
405 let mut q = Query::new();
406 self.categories.push_query("categories[]", &mut q);
407 self.include.push_query("include[]", &mut q);
408 q
409 }
410}
411
412#[derive(Debug, Clone, Default)]
414pub struct DeleteDbfieldsFieldIdOptionsOptionIdQuery {
415 pub dry_run: Option<bool>,
417}
418
419impl DeleteDbfieldsFieldIdOptionsOptionIdQuery {
420 pub(crate) fn to_query(&self) -> Query {
421 let mut q = Query::new();
422 self.dry_run.push_query("dryRun", &mut q);
423 q
424 }
425}
426
427#[derive(Debug, Clone, Default)]
429pub struct GetDomainobjectsQuery {
430 pub domain_types: Option<Vec<String>>,
433 pub domain_identifiers: Option<Vec<String>>,
435}
436
437impl GetDomainobjectsQuery {
438 pub(crate) fn to_query(&self) -> Query {
439 let mut q = Query::new();
440 self.domain_types.push_query("domain_types[]", &mut q);
441 self.domain_identifiers.push_query("domain_identifiers[]", &mut q);
442 q
443 }
444}
445
446#[derive(Debug, Clone, Default)]
448pub struct PostEventsIcalQuery {
449 pub person_id: Option<i64>,
451}
452
453impl PostEventsIcalQuery {
454 pub(crate) fn to_query(&self) -> Query {
455 let mut q = Query::new();
456 self.person_id.push_query("personId", &mut q);
457 q
458 }
459}
460
461#[derive(Debug, Clone, Default)]
463pub struct DeleteEventsIdQuery {
464 pub dry_run: Option<bool>,
466 pub send_mail: Option<bool>,
468}
469
470impl DeleteEventsIdQuery {
471 pub(crate) fn to_query(&self) -> Query {
472 let mut q = Query::new();
473 self.dry_run.push_query("dryRun", &mut q);
474 self.send_mail.push_query("sendMail", &mut q);
475 q
476 }
477}
478
479#[derive(Debug, Clone, Default)]
481pub struct GetEventsIcalQuery {
482 pub person_id: Option<i64>,
484}
485
486impl GetEventsIcalQuery {
487 pub(crate) fn to_query(&self) -> Query {
488 let mut q = Query::new();
489 self.person_id.push_query("personId", &mut q);
490 q
491 }
492}
493
494#[derive(Debug, Clone, Default)]
496pub struct GetEventsQuery {
497 pub from: Option<chrono::NaiveDate>,
499 pub to: Option<chrono::NaiveDate>,
501 pub direction: Option<String>,
504 pub limit: Option<i64>,
506 pub canceled: Option<bool>,
508 pub include: Option<String>,
510}
511
512impl GetEventsQuery {
513 pub(crate) fn to_query(&self) -> Query {
514 let mut q = Query::new();
515 self.from.push_query("from", &mut q);
516 self.to.push_query("to", &mut q);
517 self.direction.push_query("direction", &mut q);
518 self.limit.push_query("limit", &mut q);
519 self.canceled.push_query("canceled", &mut q);
520 self.include.push_query("include", &mut q);
521 q
522 }
523}
524
525#[derive(Debug, Clone, Default)]
527pub struct PostEventsIdAgendaExportQuery {
528 pub format: Option<String>,
531}
532
533impl PostEventsIdAgendaExportQuery {
534 pub(crate) fn to_query(&self) -> Query {
535 let mut q = Query::new();
536 self.format.push_query("format", &mut q);
537 q
538 }
539}
540
541#[derive(Debug, Clone, Default)]
543pub struct PostEventsIdAgendaIntegrateQuery {
544 pub event_id: Option<i64>,
546}
547
548impl PostEventsIdAgendaIntegrateQuery {
549 pub(crate) fn to_query(&self) -> Query {
550 let mut q = Query::new();
551 self.event_id.push_query("event_id", &mut q);
552 q
553 }
554}
555
556#[derive(Debug, Clone, Default)]
558pub struct PutEventsIdAgendaQuery {
559 pub template_id: Option<i64>,
561 pub event_id: Option<i64>,
563}
564
565impl PutEventsIdAgendaQuery {
566 pub(crate) fn to_query(&self) -> Query {
567 let mut q = Query::new();
568 self.template_id.push_query("template_id", &mut q);
569 self.event_id.push_query("event_id", &mut q);
570 q
571 }
572}
573
574#[derive(Debug, Clone, Default)]
576pub struct PostEventsIdAgendaItemsQuery {
577 pub before_id: Option<i64>,
579 pub after_id: Option<i64>,
581 #[deprecated = "Use `before_id` or `after_id` to position an item."]
583 pub sort_key: Option<i64>,
584}
585
586impl PostEventsIdAgendaItemsQuery {
587 pub(crate) fn to_query(&self) -> Query {
588 let mut q = Query::new();
589 self.before_id.push_query("before_id", &mut q);
590 self.after_id.push_query("after_id", &mut q);
591 self.sort_key.push_query("sortKey", &mut q);
592 q
593 }
594}
595
596#[derive(Debug, Clone, Default)]
598pub struct PutEventsIdAgendaItemsIdQuery {
599 pub before_id: Option<i64>,
601 pub after_id: Option<i64>,
603 #[deprecated = "Use `before_id` or `after_id` to position an item."]
605 pub sort_key: Option<i64>,
606}
607
608impl PutEventsIdAgendaItemsIdQuery {
609 pub(crate) fn to_query(&self) -> Query {
610 let mut q = Query::new();
611 self.before_id.push_query("before_id", &mut q);
612 self.after_id.push_query("after_id", &mut q);
613 self.sort_key.push_query("sortKey", &mut q);
614 q
615 }
616}
617
618#[derive(Debug, Clone, Default)]
620pub struct PostEventsFactsExportQuery {
621 pub format: Option<String>,
624}
625
626impl PostEventsFactsExportQuery {
627 pub(crate) fn to_query(&self) -> Query {
628 let mut q = Query::new();
629 self.format.push_query("format", &mut q);
630 q
631 }
632}
633
634#[derive(Debug, Clone, Default)]
636pub struct GetEventsFactsQuery {
637 pub from: Option<chrono::NaiveDate>,
639 pub to: Option<chrono::NaiveDate>,
641 pub event_id: Option<Vec<i64>>,
643 pub fact_id: Option<Vec<i64>>,
645 pub limit: Option<i64>,
647}
648
649impl GetEventsFactsQuery {
650 pub(crate) fn to_query(&self) -> Query {
651 let mut q = Query::new();
652 self.from.push_query("from", &mut q);
653 self.to.push_query("to", &mut q);
654 self.event_id.push_query("event_id[]", &mut q);
655 self.fact_id.push_query("fact_id[]", &mut q);
656 self.limit.push_query("limit", &mut q);
657 q
658 }
659}
660
661#[derive(Debug, Clone, Default)]
663pub struct GetExternalloginsOidcCallbackQuery {
664 pub state: Option<String>,
666 pub code: Option<String>,
668 pub error: Option<String>,
670}
671
672impl GetExternalloginsOidcCallbackQuery {
673 pub(crate) fn to_query(&self) -> Query {
674 let mut q = Query::new();
675 self.state.push_query("state", &mut q);
676 self.code.push_query("code", &mut q);
677 self.error.push_query("error", &mut q);
678 q
679 }
680}
681
682#[derive(Debug, Clone, Default)]
684pub struct GetExternalloginsIdOidcCallbackQuery {
685 pub state: Option<String>,
687 pub code: Option<String>,
689 pub error: Option<String>,
691}
692
693impl GetExternalloginsIdOidcCallbackQuery {
694 pub(crate) fn to_query(&self) -> Query {
695 let mut q = Query::new();
696 self.state.push_query("state", &mut q);
697 self.code.push_query("code", &mut q);
698 self.error.push_query("error", &mut q);
699 q
700 }
701}
702
703#[derive(Debug, Clone, Default)]
705pub struct GetExternalloginsIdOidcStartQuery {
706 pub redirect: Option<String>,
708}
709
710impl GetExternalloginsIdOidcStartQuery {
711 pub(crate) fn to_query(&self) -> Query {
712 let mut q = Query::new();
713 self.redirect.push_query("redirect", &mut q);
714 q
715 }
716}
717
718#[derive(Debug, Clone, Default)]
720pub struct PostExternalloginsExternalLoginIdSamlSlsQuery {
721 pub saml_request: Option<String>,
723 pub saml_response: Option<String>,
725 pub relay_state: Option<String>,
727 pub sig_alg: Option<String>,
729 pub signature: Option<String>,
731}
732
733impl PostExternalloginsExternalLoginIdSamlSlsQuery {
734 pub(crate) fn to_query(&self) -> Query {
735 let mut q = Query::new();
736 self.saml_request.push_query("SAMLRequest", &mut q);
737 self.saml_response.push_query("SAMLResponse", &mut q);
738 self.relay_state.push_query("RelayState", &mut q);
739 self.sig_alg.push_query("SigAlg", &mut q);
740 self.signature.push_query("Signature", &mut q);
741 q
742 }
743}
744
745#[derive(Debug, Clone, Default)]
747pub struct DeleteExternalloginsExternalLoginIdSamlSlsQuery {
748 pub saml_request: Option<String>,
750 pub saml_response: Option<String>,
752 pub relay_state: Option<String>,
754 pub sig_alg: Option<String>,
756 pub signature: Option<String>,
758}
759
760impl DeleteExternalloginsExternalLoginIdSamlSlsQuery {
761 pub(crate) fn to_query(&self) -> Query {
762 let mut q = Query::new();
763 self.saml_request.push_query("SAMLRequest", &mut q);
764 self.saml_response.push_query("SAMLResponse", &mut q);
765 self.relay_state.push_query("RelayState", &mut q);
766 self.sig_alg.push_query("SigAlg", &mut q);
767 self.signature.push_query("Signature", &mut q);
768 q
769 }
770}
771
772#[derive(Debug, Clone, Default)]
774pub struct GetExternalloginsExternalLoginIdSamlLoginQuery {
775 pub redirect: Option<String>,
777}
778
779impl GetExternalloginsExternalLoginIdSamlLoginQuery {
780 pub(crate) fn to_query(&self) -> Query {
781 let mut q = Query::new();
782 self.redirect.push_query("redirect", &mut q);
783 q
784 }
785}
786
787#[derive(Debug, Clone, Default)]
789pub struct GetExternalloginsExternalLoginIdSamlSlsQuery {
790 pub saml_request: Option<String>,
792 pub saml_response: Option<String>,
794 pub relay_state: Option<String>,
796 pub sig_alg: Option<String>,
798 pub signature: Option<String>,
800}
801
802impl GetExternalloginsExternalLoginIdSamlSlsQuery {
803 pub(crate) fn to_query(&self) -> Query {
804 let mut q = Query::new();
805 self.saml_request.push_query("SAMLRequest", &mut q);
806 self.saml_response.push_query("SAMLResponse", &mut q);
807 self.relay_state.push_query("RelayState", &mut q);
808 self.sig_alg.push_query("SigAlg", &mut q);
809 self.signature.push_query("Signature", &mut q);
810 q
811 }
812}
813
814#[derive(Debug, Clone, Default)]
816pub struct PatchExternalloginsExternalLoginIdSamlSlsQuery {
817 pub saml_request: Option<String>,
819 pub saml_response: Option<String>,
821 pub relay_state: Option<String>,
823 pub sig_alg: Option<String>,
825 pub signature: Option<String>,
827}
828
829impl PatchExternalloginsExternalLoginIdSamlSlsQuery {
830 pub(crate) fn to_query(&self) -> Query {
831 let mut q = Query::new();
832 self.saml_request.push_query("SAMLRequest", &mut q);
833 self.saml_response.push_query("SAMLResponse", &mut q);
834 self.relay_state.push_query("RelayState", &mut q);
835 self.sig_alg.push_query("SigAlg", &mut q);
836 self.signature.push_query("Signature", &mut q);
837 q
838 }
839}
840
841#[derive(Debug, Clone, Default)]
843pub struct PutExternalloginsExternalLoginIdSamlSlsQuery {
844 pub saml_request: Option<String>,
846 pub saml_response: Option<String>,
848 pub relay_state: Option<String>,
850 pub sig_alg: Option<String>,
852 pub signature: Option<String>,
854}
855
856impl PutExternalloginsExternalLoginIdSamlSlsQuery {
857 pub(crate) fn to_query(&self) -> Query {
858 let mut q = Query::new();
859 self.saml_request.push_query("SAMLRequest", &mut q);
860 self.saml_response.push_query("SAMLResponse", &mut q);
861 self.relay_state.push_query("RelayState", &mut q);
862 self.sig_alg.push_query("SigAlg", &mut q);
863 self.signature.push_query("Signature", &mut q);
864 q
865 }
866}
867
868#[derive(Debug, Clone, Default)]
870pub struct GetExternalpostsQuery {
871 pub before: Option<chrono::DateTime<chrono::Utc>>,
873 pub last_post_indentifier: Option<String>,
875 pub after: Option<chrono::DateTime<chrono::Utc>>,
877 pub external_group_guid: Option<Vec<String>>,
879 pub external_instance_guid: Option<Vec<String>>,
881 pub include: Option<Vec<String>>,
884 pub limit: Option<i64>,
886}
887
888impl GetExternalpostsQuery {
889 pub(crate) fn to_query(&self) -> Query {
890 let mut q = Query::new();
891 self.before.push_query("before", &mut q);
892 self.last_post_indentifier.push_query("last_post_indentifier", &mut q);
893 self.after.push_query("after", &mut q);
894 self.external_group_guid.push_query("external_group_guid[]", &mut q);
895 self.external_instance_guid.push_query("external_instance_guid[]", &mut q);
896 self.include.push_query("include[]", &mut q);
897 self.limit.push_query("limit", &mut q);
898 q
899 }
900}
901
902#[derive(Debug, Clone, Default)]
904pub struct DeleteFactsIdQuery {
905 pub dry_run: Option<bool>,
907}
908
909impl DeleteFactsIdQuery {
910 pub(crate) fn to_query(&self) -> Query {
911 let mut q = Query::new();
912 self.dry_run.push_query("dry_run", &mut q);
913 q
914 }
915}
916
917#[derive(Debug, Clone, Default)]
919pub struct PostFilesDomainTypeDomainIdentifierForm {
920 pub image_options: Option<String>,
922 pub securitylevel_id: Option<i64>,
924 pub sort_key: Option<i64>,
926}
927
928impl PostFilesDomainTypeDomainIdentifierForm {
929 pub(crate) fn to_query(&self) -> Query {
930 let mut q = Query::new();
931 self.image_options.push_query("image_options", &mut q);
932 self.securitylevel_id.push_query("securitylevel_id", &mut q);
933 self.sort_key.push_query("sortKey", &mut q);
934 q
935 }
936}
937
938#[derive(Debug, Clone, Default)]
940pub struct GetFinanceMasterdataQuery {
941 pub accounting_period_id: Option<i64>,
943}
944
945impl GetFinanceMasterdataQuery {
946 pub(crate) fn to_query(&self) -> Query {
947 let mut q = Query::new();
948 self.accounting_period_id.push_query("accounting_period_id", &mut q);
949 q
950 }
951}
952
953#[derive(Debug, Clone, Default)]
955pub struct DeleteFinanceAccountclassesIdQuery {
956 pub dry_run: Option<bool>,
958}
959
960impl DeleteFinanceAccountclassesIdQuery {
961 pub(crate) fn to_query(&self) -> Query {
962 let mut q = Query::new();
963 self.dry_run.push_query("dry_run", &mut q);
964 q
965 }
966}
967
968#[derive(Debug, Clone, Default)]
970pub struct DeleteFinanceAccountgroupsIdQuery {
971 pub dry_run: Option<bool>,
973}
974
975impl DeleteFinanceAccountgroupsIdQuery {
976 pub(crate) fn to_query(&self) -> Query {
977 let mut q = Query::new();
978 self.dry_run.push_query("dry_run", &mut q);
979 q
980 }
981}
982
983#[derive(Debug, Clone, Default)]
985pub struct DeleteFinanceAccounttypesIdQuery {
986 pub dry_run: Option<bool>,
988}
989
990impl DeleteFinanceAccounttypesIdQuery {
991 pub(crate) fn to_query(&self) -> Query {
992 let mut q = Query::new();
993 self.dry_run.push_query("dry_run", &mut q);
994 q
995 }
996}
997
998#[derive(Debug, Clone, Default)]
1000pub struct DeleteFinanceAccountingperiodsIdQuery {
1001 pub dry_run: Option<bool>,
1003}
1004
1005impl DeleteFinanceAccountingperiodsIdQuery {
1006 pub(crate) fn to_query(&self) -> Query {
1007 let mut q = Query::new();
1008 self.dry_run.push_query("dry_run", &mut q);
1009 q
1010 }
1011}
1012
1013#[derive(Debug, Clone, Default)]
1015pub struct GetFinanceAccountingperiodsIdBillsQuery {
1016 pub limit: Option<i64>,
1018 pub order_by: Option<String>,
1021 pub order_direction: Option<String>,
1024}
1025
1026impl GetFinanceAccountingperiodsIdBillsQuery {
1027 pub(crate) fn to_query(&self) -> Query {
1028 let mut q = Query::new();
1029 self.limit.push_query("limit", &mut q);
1030 self.order_by.push_query("order_by", &mut q);
1031 self.order_direction.push_query("order_direction", &mut q);
1032 q
1033 }
1034}
1035
1036#[derive(Debug, Clone, Default)]
1038pub struct GetFinanceAccountingperiodsIdAccountsIdMovementsQuery {
1039 pub limit: Option<i64>,
1041 pub state: Option<String>,
1044 pub query: Option<String>,
1046 pub include: Option<Vec<String>>,
1049}
1050
1051impl GetFinanceAccountingperiodsIdAccountsIdMovementsQuery {
1052 pub(crate) fn to_query(&self) -> Query {
1053 let mut q = Query::new();
1054 self.limit.push_query("limit", &mut q);
1055 self.state.push_query("state", &mut q);
1056 self.query.push_query("query", &mut q);
1057 self.include.push_query("include[]", &mut q);
1058 q
1059 }
1060}
1061
1062#[derive(Debug, Clone, Default)]
1064pub struct GetFinanceAccountingperiodsIdAccountsIdStatementsIdMovementsQuery {
1065 pub limit: Option<i64>,
1067 pub state: Option<String>,
1070 pub query: Option<String>,
1072 pub include: Option<Vec<String>>,
1075}
1076
1077impl GetFinanceAccountingperiodsIdAccountsIdStatementsIdMovementsQuery {
1078 pub(crate) fn to_query(&self) -> Query {
1079 let mut q = Query::new();
1080 self.limit.push_query("limit", &mut q);
1081 self.state.push_query("state", &mut q);
1082 self.query.push_query("query", &mut q);
1083 self.include.push_query("include[]", &mut q);
1084 q
1085 }
1086}
1087
1088#[derive(Debug, Clone, Default)]
1090pub struct DeleteFinanceAccountsIdQuery {
1091 pub dry_run: Option<bool>,
1093}
1094
1095impl DeleteFinanceAccountsIdQuery {
1096 pub(crate) fn to_query(&self) -> Query {
1097 let mut q = Query::new();
1098 self.dry_run.push_query("dry_run", &mut q);
1099 q
1100 }
1101}
1102
1103#[derive(Debug, Clone, Default)]
1105pub struct GetFinanceAccountsCsvQuery {
1106 pub accounting_period_id: Option<i64>,
1108}
1109
1110impl GetFinanceAccountsCsvQuery {
1111 pub(crate) fn to_query(&self) -> Query {
1112 let mut q = Query::new();
1113 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1114 q
1115 }
1116}
1117
1118#[derive(Debug, Clone, Default)]
1120pub struct GetFinanceAccountsExportQuery {
1121 pub accounting_period_id: Option<i64>,
1123 pub format: Option<String>,
1126 #[deprecated = "deprecated in the ChurchTools API"]
1129 pub r#type: Option<String>,
1130}
1131
1132impl GetFinanceAccountsExportQuery {
1133 pub(crate) fn to_query(&self) -> Query {
1134 let mut q = Query::new();
1135 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1136 self.format.push_query("format", &mut q);
1137 self.r#type.push_query("type", &mut q);
1138 q
1139 }
1140}
1141
1142#[derive(Debug, Clone, Default)]
1144pub struct GetFinanceAccountsQuery {
1145 pub accounting_period_id: Option<serde_json::Value>,
1147 pub calculate_balance: Option<bool>,
1149}
1150
1151impl GetFinanceAccountsQuery {
1152 pub(crate) fn to_query(&self) -> Query {
1153 let mut q = Query::new();
1154 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1155 self.calculate_balance.push_query("calculate_balance", &mut q);
1156 q
1157 }
1158}
1159
1160#[derive(Debug, Clone, Default)]
1162pub struct DeleteFinanceBillsIdQuery {
1163 pub dry_run: Option<bool>,
1165}
1166
1167impl DeleteFinanceBillsIdQuery {
1168 pub(crate) fn to_query(&self) -> Query {
1169 let mut q = Query::new();
1170 self.dry_run.push_query("dry_run", &mut q);
1171 q
1172 }
1173}
1174
1175#[derive(Debug, Clone, Default)]
1177pub struct DeleteFinanceCashdiscountsIdQuery {
1178 pub dry_run: Option<bool>,
1180}
1181
1182impl DeleteFinanceCashdiscountsIdQuery {
1183 pub(crate) fn to_query(&self) -> Query {
1184 let mut q = Query::new();
1185 self.dry_run.push_query("dry_run", &mut q);
1186 q
1187 }
1188}
1189
1190#[derive(Debug, Clone, Default)]
1192pub struct GetFinanceCashdiscountsQuery {
1193 pub accounting_period_id: Option<i64>,
1195}
1196
1197impl GetFinanceCashdiscountsQuery {
1198 pub(crate) fn to_query(&self) -> Query {
1199 let mut q = Query::new();
1200 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1201 q
1202 }
1203}
1204
1205#[derive(Debug, Clone, Default)]
1207pub struct DeleteFinanceClientsIdQuery {
1208 pub dry_run: Option<bool>,
1210}
1211
1212impl DeleteFinanceClientsIdQuery {
1213 pub(crate) fn to_query(&self) -> Query {
1214 let mut q = Query::new();
1215 self.dry_run.push_query("dry_run", &mut q);
1216 q
1217 }
1218}
1219
1220#[derive(Debug, Clone, Default)]
1222pub struct DeleteFinanceCostcentersIdQuery {
1223 pub dry_run: Option<bool>,
1225}
1226
1227impl DeleteFinanceCostcentersIdQuery {
1228 pub(crate) fn to_query(&self) -> Query {
1229 let mut q = Query::new();
1230 self.dry_run.push_query("dry_run", &mut q);
1231 q
1232 }
1233}
1234
1235#[derive(Debug, Clone, Default)]
1237pub struct GetFinanceCostcentersExportQuery {
1238 pub accounting_period_id: Option<i64>,
1240 pub format: Option<String>,
1243 #[deprecated = "deprecated in the ChurchTools API"]
1246 pub r#type: Option<String>,
1247}
1248
1249impl GetFinanceCostcentersExportQuery {
1250 pub(crate) fn to_query(&self) -> Query {
1251 let mut q = Query::new();
1252 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1253 self.format.push_query("format", &mut q);
1254 self.r#type.push_query("type", &mut q);
1255 q
1256 }
1257}
1258
1259#[derive(Debug, Clone, Default)]
1261pub struct GetFinanceCostcentersQuery {
1262 pub accounting_period_id: Option<i64>,
1264}
1265
1266impl GetFinanceCostcentersQuery {
1267 pub(crate) fn to_query(&self) -> Query {
1268 let mut q = Query::new();
1269 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1270 q
1271 }
1272}
1273
1274#[derive(Debug, Clone, Default)]
1276pub struct DeleteFinanceDonatorsDonatorCoupleIdQuery {
1277 pub accounting_period_id: Option<i64>,
1279}
1280
1281impl DeleteFinanceDonatorsDonatorCoupleIdQuery {
1282 pub(crate) fn to_query(&self) -> Query {
1283 let mut q = Query::new();
1284 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1285 q
1286 }
1287}
1288
1289#[derive(Debug, Clone, Default)]
1291pub struct DeleteFinanceDonatorsReceiptsQuery {
1292 pub accounting_period_id: Option<i64>,
1294}
1295
1296impl DeleteFinanceDonatorsReceiptsQuery {
1297 pub(crate) fn to_query(&self) -> Query {
1298 let mut q = Query::new();
1299 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1300 q
1301 }
1302}
1303
1304#[derive(Debug, Clone, Default)]
1306pub struct GetFinanceDonatorsReceiptsQuery {
1307 pub accounting_period_id: Option<i64>,
1309 pub mode: Option<String>,
1312 pub cleardoublepage: Option<String>,
1315}
1316
1317impl GetFinanceDonatorsReceiptsQuery {
1318 pub(crate) fn to_query(&self) -> Query {
1319 let mut q = Query::new();
1320 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1321 self.mode.push_query("mode", &mut q);
1322 self.cleardoublepage.push_query("cleardoublepage", &mut q);
1323 q
1324 }
1325}
1326
1327#[derive(Debug, Clone, Default)]
1329pub struct GetFinanceDonatorsDonatorCoupleIdQuery {
1330 pub accounting_period_id: Option<i64>,
1332 pub r#type: Option<String>,
1335}
1336
1337impl GetFinanceDonatorsDonatorCoupleIdQuery {
1338 pub(crate) fn to_query(&self) -> Query {
1339 let mut q = Query::new();
1340 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1341 self.r#type.push_query("type", &mut q);
1342 q
1343 }
1344}
1345
1346#[derive(Debug, Clone, Default)]
1348pub struct GetFinanceDonatorsQuery {
1349 pub accounting_period_id: Option<i64>,
1351 pub only_incomplete: Option<bool>,
1353 pub order_by: Option<String>,
1356 pub order_direction: Option<String>,
1359 pub query: Option<String>,
1361 pub limit: Option<i64>,
1363}
1364
1365impl GetFinanceDonatorsQuery {
1366 pub(crate) fn to_query(&self) -> Query {
1367 let mut q = Query::new();
1368 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1369 self.only_incomplete.push_query("only_incomplete", &mut q);
1370 self.order_by.push_query("order_by", &mut q);
1371 self.order_direction.push_query("order_direction", &mut q);
1372 self.query.push_query("query", &mut q);
1373 self.limit.push_query("limit", &mut q);
1374 q
1375 }
1376}
1377
1378#[derive(Debug, Clone, Default)]
1380pub struct GetFinanceEubpSubmissionsQuery {
1381 pub client_id: Option<i64>,
1383}
1384
1385impl GetFinanceEubpSubmissionsQuery {
1386 pub(crate) fn to_query(&self) -> Query {
1387 let mut q = Query::new();
1388 self.client_id.push_query("client_id", &mut q);
1389 q
1390 }
1391}
1392
1393#[derive(Debug, Clone, Default)]
1395pub struct GetFinanceEubpSubmissionsIdAccountsQuery {
1396 pub client_id: Option<i64>,
1398}
1399
1400impl GetFinanceEubpSubmissionsIdAccountsQuery {
1401 pub(crate) fn to_query(&self) -> Query {
1402 let mut q = Query::new();
1403 self.client_id.push_query("client_id", &mut q);
1404 q
1405 }
1406}
1407
1408#[derive(Debug, Clone, Default)]
1410pub struct PostFinanceSplittransactionsQuery {
1411 pub ignore_donation_constraint: Option<bool>,
1413}
1414
1415impl PostFinanceSplittransactionsQuery {
1416 pub(crate) fn to_query(&self) -> Query {
1417 let mut q = Query::new();
1418 self.ignore_donation_constraint.push_query("ignoreDonationConstraint", &mut q);
1419 q
1420 }
1421}
1422
1423#[derive(Debug, Clone, Default)]
1425pub struct DeleteFinanceSplittransactionsIdQuery {
1426 pub dry_run: Option<bool>,
1428 pub include: Option<Vec<String>>,
1431}
1432
1433impl DeleteFinanceSplittransactionsIdQuery {
1434 pub(crate) fn to_query(&self) -> Query {
1435 let mut q = Query::new();
1436 self.dry_run.push_query("dry_run", &mut q);
1437 self.include.push_query("include[]", &mut q);
1438 q
1439 }
1440}
1441
1442#[derive(Debug, Clone, Default)]
1444pub struct GetFinanceSplittransactionsIdQuery {
1445 pub include: Option<Vec<String>>,
1448}
1449
1450impl GetFinanceSplittransactionsIdQuery {
1451 pub(crate) fn to_query(&self) -> Query {
1452 let mut q = Query::new();
1453 self.include.push_query("include[]", &mut q);
1454 q
1455 }
1456}
1457
1458#[derive(Debug, Clone, Default)]
1460pub struct PutFinanceSplittransactionsIdQuery {
1461 pub ignore_donation_constraint: Option<bool>,
1463 pub include: Option<Vec<String>>,
1466}
1467
1468impl PutFinanceSplittransactionsIdQuery {
1469 pub(crate) fn to_query(&self) -> Query {
1470 let mut q = Query::new();
1471 self.ignore_donation_constraint.push_query("ignoreDonationConstraint", &mut q);
1472 self.include.push_query("include[]", &mut q);
1473 q
1474 }
1475}
1476
1477#[derive(Debug, Clone, Default)]
1479pub struct DeleteFinanceTaxratesIdQuery {
1480 pub dry_run: Option<bool>,
1482}
1483
1484impl DeleteFinanceTaxratesIdQuery {
1485 pub(crate) fn to_query(&self) -> Query {
1486 let mut q = Query::new();
1487 self.dry_run.push_query("dry_run", &mut q);
1488 q
1489 }
1490}
1491
1492#[derive(Debug, Clone, Default)]
1494pub struct GetFinanceTaxratesQuery {
1495 pub accounting_period_id: Option<i64>,
1497}
1498
1499impl GetFinanceTaxratesQuery {
1500 pub(crate) fn to_query(&self) -> Query {
1501 let mut q = Query::new();
1502 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1503 q
1504 }
1505}
1506
1507#[derive(Debug, Clone, Default)]
1509pub struct DeleteFinanceTaxtypesIdQuery {
1510 pub dry_run: Option<bool>,
1512}
1513
1514impl DeleteFinanceTaxtypesIdQuery {
1515 pub(crate) fn to_query(&self) -> Query {
1516 let mut q = Query::new();
1517 self.dry_run.push_query("dry_run", &mut q);
1518 q
1519 }
1520}
1521
1522#[derive(Debug, Clone, Default)]
1524pub struct PostFinanceTemplatesIdQuery {
1525 pub accounting_period_id: Option<i64>,
1527}
1528
1529impl PostFinanceTemplatesIdQuery {
1530 pub(crate) fn to_query(&self) -> Query {
1531 let mut q = Query::new();
1532 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1533 q
1534 }
1535}
1536
1537#[derive(Debug, Clone, Default)]
1539pub struct GetFinanceTemplatesExportQuery {
1540 pub accounting_period_id: Option<i64>,
1542}
1543
1544impl GetFinanceTemplatesExportQuery {
1545 pub(crate) fn to_query(&self) -> Query {
1546 let mut q = Query::new();
1547 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1548 q
1549 }
1550}
1551
1552#[derive(Debug, Clone, Default)]
1554pub struct DeleteFinanceTransactionpurposesIdQuery {
1555 pub dry_run: Option<bool>,
1557}
1558
1559impl DeleteFinanceTransactionpurposesIdQuery {
1560 pub(crate) fn to_query(&self) -> Query {
1561 let mut q = Query::new();
1562 self.dry_run.push_query("dry_run", &mut q);
1563 q
1564 }
1565}
1566
1567#[derive(Debug, Clone, Default)]
1569pub struct PostFinanceTransactionsBulkcreateQuery {
1570 pub ignore_donation_constraint: Option<bool>,
1572}
1573
1574impl PostFinanceTransactionsBulkcreateQuery {
1575 pub(crate) fn to_query(&self) -> Query {
1576 let mut q = Query::new();
1577 self.ignore_donation_constraint.push_query("ignoreDonationConstraint", &mut q);
1578 q
1579 }
1580}
1581
1582#[derive(Debug, Clone, Default)]
1584pub struct PostFinanceTransactionsQuery {
1585 pub ignore_donation_constraint: Option<bool>,
1587}
1588
1589impl PostFinanceTransactionsQuery {
1590 pub(crate) fn to_query(&self) -> Query {
1591 let mut q = Query::new();
1592 self.ignore_donation_constraint.push_query("ignoreDonationConstraint", &mut q);
1593 q
1594 }
1595}
1596
1597#[derive(Debug, Clone, Default)]
1599pub struct DeleteFinanceTransactionsIdQuery {
1600 pub dry_run: Option<bool>,
1602 pub include: Option<Vec<String>>,
1605}
1606
1607impl DeleteFinanceTransactionsIdQuery {
1608 pub(crate) fn to_query(&self) -> Query {
1609 let mut q = Query::new();
1610 self.dry_run.push_query("dry_run", &mut q);
1611 self.include.push_query("include[]", &mut q);
1612 q
1613 }
1614}
1615
1616#[derive(Debug, Clone, Default)]
1618pub struct GetFinanceTransactionsIdQuery {
1619 pub include: Option<Vec<String>>,
1622}
1623
1624impl GetFinanceTransactionsIdQuery {
1625 pub(crate) fn to_query(&self) -> Query {
1626 let mut q = Query::new();
1627 self.include.push_query("include[]", &mut q);
1628 q
1629 }
1630}
1631
1632#[derive(Debug, Clone, Default)]
1634pub struct GetFinanceTransactionsCsvQuery {
1635 pub accounting_period_id: Option<i64>,
1637 pub created_pid: Option<i64>,
1639 pub cost_center_ids: Option<Vec<i64>>,
1641 pub donator_ids: Option<Vec<i64>>,
1643 pub include_ids: Option<Vec<i64>>,
1645 pub exclude_ids: Option<Vec<i64>>,
1647 pub account_ids: Option<Vec<i64>>,
1649 pub is_donation: Option<bool>,
1651 pub is_income: Option<bool>,
1653 pub start_date: Option<chrono::NaiveDate>,
1655 pub end_date: Option<chrono::NaiveDate>,
1657 pub is_immutable: Option<bool>,
1659 pub order_by: Option<String>,
1662 pub order_direction: Option<String>,
1665 pub query: Option<String>,
1667 pub is_waiver_of_reimbursement_of_expenses: Option<bool>,
1669 pub target: Option<String>,
1672}
1673
1674impl GetFinanceTransactionsCsvQuery {
1675 pub(crate) fn to_query(&self) -> Query {
1676 let mut q = Query::new();
1677 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1678 self.created_pid.push_query("created_pid", &mut q);
1679 self.cost_center_ids.push_query("cost_center_ids[]", &mut q);
1680 self.donator_ids.push_query("donator_ids[]", &mut q);
1681 self.include_ids.push_query("include_ids[]", &mut q);
1682 self.exclude_ids.push_query("exclude_ids[]", &mut q);
1683 self.account_ids.push_query("account_ids[]", &mut q);
1684 self.is_donation.push_query("is_donation", &mut q);
1685 self.is_income.push_query("is_income", &mut q);
1686 self.start_date.push_query("start_date", &mut q);
1687 self.end_date.push_query("end_date", &mut q);
1688 self.is_immutable.push_query("is_immutable", &mut q);
1689 self.order_by.push_query("order_by", &mut q);
1690 self.order_direction.push_query("order_direction", &mut q);
1691 self.query.push_query("query", &mut q);
1692 self.is_waiver_of_reimbursement_of_expenses.push_query("is_waiver_of_reimbursement_of_expenses", &mut q);
1693 self.target.push_query("target", &mut q);
1694 q
1695 }
1696}
1697
1698#[derive(Debug, Clone, Default)]
1700pub struct GetFinanceTransactionsDatevexportQuery {
1701 pub accounting_period_id: Option<i64>,
1703 pub created_pid: Option<i64>,
1705 pub cost_center_ids: Option<Vec<i64>>,
1707 pub donator_ids: Option<Vec<i64>>,
1709 pub include_ids: Option<Vec<i64>>,
1711 pub exclude_ids: Option<Vec<i64>>,
1713 pub account_ids: Option<Vec<i64>>,
1715 pub is_donation: Option<bool>,
1717 pub is_income: Option<bool>,
1719 pub start_date: Option<chrono::NaiveDate>,
1721 pub end_date: Option<chrono::NaiveDate>,
1723 pub is_immutable: Option<bool>,
1725 pub order_by: Option<String>,
1728 pub order_direction: Option<String>,
1731 pub query: Option<String>,
1733 pub is_waiver_of_reimbursement_of_expenses: Option<bool>,
1735}
1736
1737impl GetFinanceTransactionsDatevexportQuery {
1738 pub(crate) fn to_query(&self) -> Query {
1739 let mut q = Query::new();
1740 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1741 self.created_pid.push_query("created_pid", &mut q);
1742 self.cost_center_ids.push_query("cost_center_ids[]", &mut q);
1743 self.donator_ids.push_query("donator_ids[]", &mut q);
1744 self.include_ids.push_query("include_ids[]", &mut q);
1745 self.exclude_ids.push_query("exclude_ids[]", &mut q);
1746 self.account_ids.push_query("account_ids[]", &mut q);
1747 self.is_donation.push_query("is_donation", &mut q);
1748 self.is_income.push_query("is_income", &mut q);
1749 self.start_date.push_query("start_date", &mut q);
1750 self.end_date.push_query("end_date", &mut q);
1751 self.is_immutable.push_query("is_immutable", &mut q);
1752 self.order_by.push_query("order_by", &mut q);
1753 self.order_direction.push_query("order_direction", &mut q);
1754 self.query.push_query("query", &mut q);
1755 self.is_waiver_of_reimbursement_of_expenses.push_query("is_waiver_of_reimbursement_of_expenses", &mut q);
1756 q
1757 }
1758}
1759
1760#[derive(Debug, Clone, Default)]
1762pub struct GetFinanceTransactionsDocumentnumberavailableQuery {
1763 pub accounting_period_id: Option<i64>,
1765 pub document_number: Option<String>,
1767}
1768
1769impl GetFinanceTransactionsDocumentnumberavailableQuery {
1770 pub(crate) fn to_query(&self) -> Query {
1771 let mut q = Query::new();
1772 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1773 self.document_number.push_query("document_number", &mut q);
1774 q
1775 }
1776}
1777
1778#[derive(Debug, Clone, Default)]
1780pub struct GetFinanceTransactionsExportQuery {
1781 pub accounting_period_id: Option<i64>,
1783 pub created_pid: Option<i64>,
1785 pub cost_center_ids: Option<Vec<i64>>,
1787 pub donator_ids: Option<Vec<i64>>,
1789 pub include_ids: Option<Vec<i64>>,
1791 pub exclude_ids: Option<Vec<i64>>,
1793 pub account_ids: Option<Vec<i64>>,
1795 pub is_donation: Option<bool>,
1797 pub is_income: Option<bool>,
1799 pub start_date: Option<chrono::NaiveDate>,
1801 pub end_date: Option<chrono::NaiveDate>,
1803 pub is_immutable: Option<bool>,
1805 pub order_by: Option<String>,
1808 pub order_direction: Option<String>,
1811 pub query: Option<String>,
1813 pub is_waiver_of_reimbursement_of_expenses: Option<bool>,
1815 pub target: Option<String>,
1818 pub format: Option<String>,
1821 #[deprecated = "Use format for new integrations."]
1824 pub r#type: Option<String>,
1825}
1826
1827impl GetFinanceTransactionsExportQuery {
1828 pub(crate) fn to_query(&self) -> Query {
1829 let mut q = Query::new();
1830 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1831 self.created_pid.push_query("created_pid", &mut q);
1832 self.cost_center_ids.push_query("cost_center_ids[]", &mut q);
1833 self.donator_ids.push_query("donator_ids[]", &mut q);
1834 self.include_ids.push_query("include_ids[]", &mut q);
1835 self.exclude_ids.push_query("exclude_ids[]", &mut q);
1836 self.account_ids.push_query("account_ids[]", &mut q);
1837 self.is_donation.push_query("is_donation", &mut q);
1838 self.is_income.push_query("is_income", &mut q);
1839 self.start_date.push_query("start_date", &mut q);
1840 self.end_date.push_query("end_date", &mut q);
1841 self.is_immutable.push_query("is_immutable", &mut q);
1842 self.order_by.push_query("order_by", &mut q);
1843 self.order_direction.push_query("order_direction", &mut q);
1844 self.query.push_query("query", &mut q);
1845 self.is_waiver_of_reimbursement_of_expenses.push_query("is_waiver_of_reimbursement_of_expenses", &mut q);
1846 self.target.push_query("target", &mut q);
1847 self.format.push_query("format", &mut q);
1848 self.r#type.push_query("type", &mut q);
1849 q
1850 }
1851}
1852
1853#[derive(Debug, Clone, Default)]
1855pub struct GetFinanceTransactionsIdsQuery {
1856 pub accounting_period_id: Option<i64>,
1858}
1859
1860impl GetFinanceTransactionsIdsQuery {
1861 pub(crate) fn to_query(&self) -> Query {
1862 let mut q = Query::new();
1863 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1864 q
1865 }
1866}
1867
1868#[derive(Debug, Clone, Default)]
1870pub struct GetFinanceTransactionsNextdocumentnumberQuery {
1871 pub accounting_period_id: Option<i64>,
1873}
1874
1875impl GetFinanceTransactionsNextdocumentnumberQuery {
1876 pub(crate) fn to_query(&self) -> Query {
1877 let mut q = Query::new();
1878 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1879 q
1880 }
1881}
1882
1883#[derive(Debug, Clone, Default)]
1885pub struct GetFinanceTransactionsSummaryQuery {
1886 pub accounting_period_id: Option<i64>,
1888 pub created_pid: Option<i64>,
1890 pub cost_center_ids: Option<Vec<i64>>,
1892 pub donator_ids: Option<Vec<i64>>,
1894 pub account_ids: Option<Vec<i64>>,
1896 pub is_donation: Option<bool>,
1898 pub is_income: Option<bool>,
1900 pub start_date: Option<chrono::NaiveDate>,
1902 pub end_date: Option<chrono::NaiveDate>,
1904 pub is_immutable: Option<bool>,
1906 pub order_by: Option<String>,
1909 pub order_direction: Option<String>,
1912 pub query: Option<String>,
1914 pub is_waiver_of_reimbursement_of_expenses: Option<bool>,
1916 pub calculation_type: Option<String>,
1919}
1920
1921impl GetFinanceTransactionsSummaryQuery {
1922 pub(crate) fn to_query(&self) -> Query {
1923 let mut q = Query::new();
1924 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1925 self.created_pid.push_query("created_pid", &mut q);
1926 self.cost_center_ids.push_query("cost_center_ids[]", &mut q);
1927 self.donator_ids.push_query("donator_ids[]", &mut q);
1928 self.account_ids.push_query("account_ids[]", &mut q);
1929 self.is_donation.push_query("is_donation", &mut q);
1930 self.is_income.push_query("is_income", &mut q);
1931 self.start_date.push_query("start_date", &mut q);
1932 self.end_date.push_query("end_date", &mut q);
1933 self.is_immutable.push_query("is_immutable", &mut q);
1934 self.order_by.push_query("order_by", &mut q);
1935 self.order_direction.push_query("order_direction", &mut q);
1936 self.query.push_query("query", &mut q);
1937 self.is_waiver_of_reimbursement_of_expenses.push_query("is_waiver_of_reimbursement_of_expenses", &mut q);
1938 self.calculation_type.push_query("calculation_type", &mut q);
1939 q
1940 }
1941}
1942
1943#[derive(Debug, Clone, Default)]
1945pub struct GetFinanceTransactionsQuery {
1946 pub accounting_period_id: Option<i64>,
1948 pub created_pid: Option<i64>,
1950 pub cost_center_ids: Option<Vec<i64>>,
1952 pub donator_ids: Option<Vec<i64>>,
1954 pub include_ids: Option<Vec<i64>>,
1956 pub exclude_ids: Option<Vec<i64>>,
1958 pub account_ids: Option<Vec<i64>>,
1960 pub is_donation: Option<bool>,
1962 pub is_income: Option<bool>,
1964 pub start_date: Option<chrono::NaiveDate>,
1966 pub end_date: Option<chrono::NaiveDate>,
1968 pub is_immutable: Option<bool>,
1970 pub exclude_stornos: Option<bool>,
1972 pub exclude_paybacks: Option<bool>,
1974 pub order_by: Option<String>,
1977 pub order_direction: Option<String>,
1980 pub limit: Option<i64>,
1982 pub include: Option<Vec<String>>,
1985 pub query: Option<String>,
1987 pub is_waiver_of_reimbursement_of_expenses: Option<bool>,
1989}
1990
1991impl GetFinanceTransactionsQuery {
1992 pub(crate) fn to_query(&self) -> Query {
1993 let mut q = Query::new();
1994 self.accounting_period_id.push_query("accounting_period_id", &mut q);
1995 self.created_pid.push_query("created_pid", &mut q);
1996 self.cost_center_ids.push_query("cost_center_ids[]", &mut q);
1997 self.donator_ids.push_query("donator_ids[]", &mut q);
1998 self.include_ids.push_query("include_ids[]", &mut q);
1999 self.exclude_ids.push_query("exclude_ids[]", &mut q);
2000 self.account_ids.push_query("account_ids[]", &mut q);
2001 self.is_donation.push_query("is_donation", &mut q);
2002 self.is_income.push_query("is_income", &mut q);
2003 self.start_date.push_query("start_date", &mut q);
2004 self.end_date.push_query("end_date", &mut q);
2005 self.is_immutable.push_query("is_immutable", &mut q);
2006 self.exclude_stornos.push_query("exclude_stornos", &mut q);
2007 self.exclude_paybacks.push_query("exclude_paybacks", &mut q);
2008 self.order_by.push_query("order_by", &mut q);
2009 self.order_direction.push_query("order_direction", &mut q);
2010 self.limit.push_query("limit", &mut q);
2011 self.include.push_query("include[]", &mut q);
2012 self.query.push_query("query", &mut q);
2013 self.is_waiver_of_reimbursement_of_expenses.push_query("is_waiver_of_reimbursement_of_expenses", &mut q);
2014 q
2015 }
2016}
2017
2018#[derive(Debug, Clone, Default)]
2020pub struct PutFinanceTransactionsIdQuery {
2021 pub include: Option<Vec<String>>,
2024}
2025
2026impl PutFinanceTransactionsIdQuery {
2027 pub(crate) fn to_query(&self) -> Query {
2028 let mut q = Query::new();
2029 self.include.push_query("include[]", &mut q);
2030 q
2031 }
2032}
2033
2034#[derive(Debug, Clone, Default)]
2036pub struct GetFollowupsQuery {
2037 pub filter: Option<Vec<String>>,
2040 pub limit: Option<i64>,
2042}
2043
2044impl GetFollowupsQuery {
2045 pub(crate) fn to_query(&self) -> Query {
2046 let mut q = Query::new();
2047 self.filter.push_query("filter[]", &mut q);
2048 self.limit.push_query("limit", &mut q);
2049 q
2050 }
2051}
2052
2053#[derive(Debug, Clone, Default)]
2055pub struct PostFollowupsFollowUpIdNotesQuery {
2056 pub also_apply_to_person: Option<bool>,
2058}
2059
2060impl PostFollowupsFollowUpIdNotesQuery {
2061 pub(crate) fn to_query(&self) -> Query {
2062 let mut q = Query::new();
2063 self.also_apply_to_person.push_query("also_apply_to_person", &mut q);
2064 q
2065 }
2066}
2067
2068#[derive(Debug, Clone, Default)]
2070pub struct DeleteGroupAgegroupsAgeGroupIdQuery {
2071 pub dry_run: Option<bool>,
2073}
2074
2075impl DeleteGroupAgegroupsAgeGroupIdQuery {
2076 pub(crate) fn to_query(&self) -> Query {
2077 let mut q = Query::new();
2078 self.dry_run.push_query("dryRun", &mut q);
2079 q
2080 }
2081}
2082
2083#[derive(Debug, Clone, Default)]
2085pub struct DeleteGroupGroupcategoriesGroupCategoryIdQuery {
2086 pub dry_run: Option<bool>,
2088}
2089
2090impl DeleteGroupGroupcategoriesGroupCategoryIdQuery {
2091 pub(crate) fn to_query(&self) -> Query {
2092 let mut q = Query::new();
2093 self.dry_run.push_query("dryRun", &mut q);
2094 q
2095 }
2096}
2097
2098#[derive(Debug, Clone, Default)]
2100pub struct DeleteGroupGrouptypesGroupTypeIdQuery {
2101 pub dry_run: Option<bool>,
2103}
2104
2105impl DeleteGroupGrouptypesGroupTypeIdQuery {
2106 pub(crate) fn to_query(&self) -> Query {
2107 let mut q = Query::new();
2108 self.dry_run.push_query("dryRun", &mut q);
2109 q
2110 }
2111}
2112
2113#[derive(Debug, Clone, Default)]
2115pub struct DeleteGroupMeetingtemplatesMeetingTemplateIdQuery {
2116 pub dry_run: Option<bool>,
2118}
2119
2120impl DeleteGroupMeetingtemplatesMeetingTemplateIdQuery {
2121 pub(crate) fn to_query(&self) -> Query {
2122 let mut q = Query::new();
2123 self.dry_run.push_query("dryRun", &mut q);
2124 q
2125 }
2126}
2127
2128#[derive(Debug, Clone, Default)]
2130pub struct DeleteGroupRolesRoleIdQuery {
2131 pub dry_run: Option<bool>,
2133}
2134
2135impl DeleteGroupRolesRoleIdQuery {
2136 pub(crate) fn to_query(&self) -> Query {
2137 let mut q = Query::new();
2138 self.dry_run.push_query("dryRun", &mut q);
2139 q
2140 }
2141}
2142
2143#[derive(Debug, Clone, Default)]
2145pub struct GetGroupRolesQuery {
2146 pub group_type_id: Option<i64>,
2148 pub response_format: Option<String>,
2151}
2152
2153impl GetGroupRolesQuery {
2154 pub(crate) fn to_query(&self) -> Query {
2155 let mut q = Query::new();
2156 self.group_type_id.push_query("group_type_id", &mut q);
2157 self.response_format.push_query("responseFormat", &mut q);
2158 q
2159 }
2160}
2161
2162#[derive(Debug, Clone, Default)]
2164pub struct DeleteGroupTargetgroupsTargetGroupIdQuery {
2165 pub dry_run: Option<bool>,
2167}
2168
2169impl DeleteGroupTargetgroupsTargetGroupIdQuery {
2170 pub(crate) fn to_query(&self) -> Query {
2171 let mut q = Query::new();
2172 self.dry_run.push_query("dryRun", &mut q);
2173 q
2174 }
2175}
2176
2177#[derive(Debug, Clone, Default)]
2179pub struct GetGrouphomepagesHashQuery {
2180 pub depth: Option<i64>,
2182}
2183
2184impl GetGrouphomepagesHashQuery {
2185 pub(crate) fn to_query(&self) -> Query {
2186 let mut q = Query::new();
2187 self.depth.push_query("depth", &mut q);
2188 q
2189 }
2190}
2191
2192#[derive(Debug, Clone, Default)]
2194pub struct DeleteGroupsGroupIdQuery {
2195 pub dry_run: Option<bool>,
2197}
2198
2199impl DeleteGroupsGroupIdQuery {
2200 pub(crate) fn to_query(&self) -> Query {
2201 let mut q = Query::new();
2202 self.dry_run.push_query("dry_run", &mut q);
2203 q
2204 }
2205}
2206
2207#[derive(Debug, Clone, Default)]
2209pub struct PostGroupsIdDuplicateQuery {
2210 pub new_name: Option<String>,
2212 pub copy_members: Option<bool>,
2214 pub copy_permissions: Option<bool>,
2216 pub copy_routines: Option<bool>,
2218}
2219
2220impl PostGroupsIdDuplicateQuery {
2221 pub(crate) fn to_query(&self) -> Query {
2222 let mut q = Query::new();
2223 self.new_name.push_query("newName", &mut q);
2224 self.copy_members.push_query("copyMembers", &mut q);
2225 self.copy_permissions.push_query("copyPermissions", &mut q);
2226 self.copy_routines.push_query("copyRoutines", &mut q);
2227 q
2228 }
2229}
2230
2231#[derive(Debug, Clone, Default)]
2233pub struct PostGroupsExportQuery {
2234 pub format: Option<String>,
2237 #[deprecated = "Use `format`"]
2240 pub r#type: Option<String>,
2241}
2242
2243impl PostGroupsExportQuery {
2244 pub(crate) fn to_query(&self) -> Query {
2245 let mut q = Query::new();
2246 self.format.push_query("format", &mut q);
2247 self.r#type.push_query("type", &mut q);
2248 q
2249 }
2250}
2251
2252#[derive(Debug, Clone, Default)]
2254pub struct GetGroupsGroupIdQuery {
2255 pub include: Option<Vec<String>>,
2258}
2259
2260impl GetGroupsGroupIdQuery {
2261 pub(crate) fn to_query(&self) -> Query {
2262 let mut q = Query::new();
2263 self.include.push_query("include[]", &mut q);
2264 q
2265 }
2266}
2267
2268#[derive(Debug, Clone, Default)]
2270pub struct GetGroupsGroupedQuery {
2271 pub group_by: Option<String>,
2274 pub limit: Option<i64>,
2276}
2277
2278impl GetGroupsGroupedQuery {
2279 pub(crate) fn to_query(&self) -> Query {
2280 let mut q = Query::new();
2281 self.group_by.push_query("group_by", &mut q);
2282 self.limit.push_query("limit", &mut q);
2283 q
2284 }
2285}
2286
2287#[derive(Debug, Clone, Default)]
2289pub struct GetGroupsQuery {
2290 pub limit: Option<i64>,
2292 pub ids: Option<Vec<i64>>,
2294 pub parent_id: Option<i64>,
2296 pub child_id: Option<i64>,
2298 pub campus_ids: Option<Vec<i64>>,
2300 pub agegroup_ids: Option<Vec<i64>>,
2302 pub group_status_ids: Option<Vec<i64>>,
2304 pub group_category_ids: Option<Vec<i64>>,
2306 pub target_group_ids: Option<Vec<i64>>,
2308 pub weekdays: Option<Vec<i64>>,
2310 pub group_type_ids: Option<Vec<i64>>,
2312 pub tag_ids: Option<Vec<i64>>,
2314 pub is_open_for_members: Option<bool>,
2316 pub without_my_groups: Option<bool>,
2318 pub only_my_groups: Option<bool>,
2320 pub has_meeting_place: Option<bool>,
2322 pub allow_posts: Option<bool>,
2324 pub has_posts: Option<bool>,
2326 pub has_active_chat: Option<bool>,
2328 pub query: Option<String>,
2329 pub visibility: Option<String>,
2332 pub order_fields: Option<Vec<String>>,
2334 pub order_directions: Option<Vec<String>>,
2337 pub include: Option<Vec<String>>,
2340}
2341
2342impl GetGroupsQuery {
2343 pub(crate) fn to_query(&self) -> Query {
2344 let mut q = Query::new();
2345 self.limit.push_query("limit", &mut q);
2346 self.ids.push_query("ids[]", &mut q);
2347 self.parent_id.push_query("parent_id", &mut q);
2348 self.child_id.push_query("child_id", &mut q);
2349 self.campus_ids.push_query("campus_ids[]", &mut q);
2350 self.agegroup_ids.push_query("agegroup_ids[]", &mut q);
2351 self.group_status_ids.push_query("group_status_ids[]", &mut q);
2352 self.group_category_ids.push_query("group_category_ids[]", &mut q);
2353 self.target_group_ids.push_query("target_group_ids[]", &mut q);
2354 self.weekdays.push_query("weekdays[]", &mut q);
2355 self.group_type_ids.push_query("group_type_ids[]", &mut q);
2356 self.tag_ids.push_query("tag_ids[]", &mut q);
2357 self.is_open_for_members.push_query("is_open_for_members", &mut q);
2358 self.without_my_groups.push_query("without_my_groups", &mut q);
2359 self.only_my_groups.push_query("only_my_groups", &mut q);
2360 self.has_meeting_place.push_query("has_meeting_place", &mut q);
2361 self.allow_posts.push_query("allow_posts", &mut q);
2362 self.has_posts.push_query("has_posts", &mut q);
2363 self.has_active_chat.push_query("has_active_chat", &mut q);
2364 self.query.push_query("query", &mut q);
2365 self.visibility.push_query("visibility", &mut q);
2366 self.order_fields.push_query("order_fields[]", &mut q);
2367 self.order_directions.push_query("order_directions[]", &mut q);
2368 self.include.push_query("include[]", &mut q);
2369 q
2370 }
2371}
2372
2373#[derive(Debug, Clone, Default)]
2375pub struct GetGroupsAbsencesQuery {
2376 pub from: Option<serde_json::Value>,
2378 pub to: Option<serde_json::Value>,
2380 pub order_direction: Option<String>,
2383 #[deprecated = "deprecated in the ChurchTools API"]
2385 pub from_date: Option<serde_json::Value>,
2386 #[deprecated = "deprecated in the ChurchTools API"]
2388 pub to_date: Option<serde_json::Value>,
2389}
2390
2391impl GetGroupsAbsencesQuery {
2392 pub(crate) fn to_query(&self) -> Query {
2393 let mut q = Query::new();
2394 self.from.push_query("from", &mut q);
2395 self.to.push_query("to", &mut q);
2396 self.order_direction.push_query("order_direction", &mut q);
2397 self.from_date.push_query("from_date", &mut q);
2398 self.to_date.push_query("to_date", &mut q);
2399 q
2400 }
2401}
2402
2403#[derive(Debug, Clone, Default)]
2405pub struct GetGroupsGroupIdChildrenQuery {
2406 pub limit: Option<i64>,
2408 pub ids: Option<Vec<i64>>,
2410 pub campus_ids: Option<Vec<i64>>,
2412 pub agegroup_ids: Option<Vec<i64>>,
2414 pub group_status_ids: Option<Vec<i64>>,
2416 pub group_category_ids: Option<Vec<i64>>,
2418 pub target_group_ids: Option<Vec<i64>>,
2420 pub weekdays: Option<Vec<i64>>,
2422 pub group_type_ids: Option<Vec<i64>>,
2424 pub tag_ids: Option<Vec<i64>>,
2426 pub is_open_for_members: Option<bool>,
2428 pub without_my_groups: Option<bool>,
2430 pub only_my_groups: Option<bool>,
2432 pub has_meeting_place: Option<bool>,
2434 pub allow_posts: Option<bool>,
2436 pub has_posts: Option<bool>,
2438 pub has_active_chat: Option<bool>,
2440 pub query: Option<String>,
2441 pub visibility: Option<String>,
2444}
2445
2446impl GetGroupsGroupIdChildrenQuery {
2447 pub(crate) fn to_query(&self) -> Query {
2448 let mut q = Query::new();
2449 self.limit.push_query("limit", &mut q);
2450 self.ids.push_query("ids[]", &mut q);
2451 self.campus_ids.push_query("campus_ids[]", &mut q);
2452 self.agegroup_ids.push_query("agegroup_ids[]", &mut q);
2453 self.group_status_ids.push_query("group_status_ids[]", &mut q);
2454 self.group_category_ids.push_query("group_category_ids[]", &mut q);
2455 self.target_group_ids.push_query("target_group_ids[]", &mut q);
2456 self.weekdays.push_query("weekdays[]", &mut q);
2457 self.group_type_ids.push_query("group_type_ids[]", &mut q);
2458 self.tag_ids.push_query("tag_ids[]", &mut q);
2459 self.is_open_for_members.push_query("is_open_for_members", &mut q);
2460 self.without_my_groups.push_query("without_my_groups", &mut q);
2461 self.only_my_groups.push_query("only_my_groups", &mut q);
2462 self.has_meeting_place.push_query("has_meeting_place", &mut q);
2463 self.allow_posts.push_query("allow_posts", &mut q);
2464 self.has_posts.push_query("has_posts", &mut q);
2465 self.has_active_chat.push_query("has_active_chat", &mut q);
2466 self.query.push_query("query", &mut q);
2467 self.visibility.push_query("visibility", &mut q);
2468 q
2469 }
2470}
2471
2472#[derive(Debug, Clone, Default)]
2474pub struct GetGroupsHierarchiesQuery {
2475 pub limit: Option<i64>,
2477 pub ids: Option<Vec<i64>>,
2479 pub campus_ids: Option<Vec<i64>>,
2481 pub agegroup_ids: Option<Vec<i64>>,
2483 pub group_status_ids: Option<Vec<i64>>,
2485 pub group_category_ids: Option<Vec<i64>>,
2487 pub target_group_ids: Option<Vec<i64>>,
2489 pub weekdays: Option<Vec<i64>>,
2491 pub group_type_ids: Option<Vec<i64>>,
2493 pub tag_ids: Option<Vec<i64>>,
2495 pub is_open_for_members: Option<bool>,
2497 pub without_my_groups: Option<bool>,
2499 pub only_my_groups: Option<bool>,
2501 pub has_meeting_place: Option<bool>,
2503 pub allow_posts: Option<bool>,
2505 pub has_posts: Option<bool>,
2507 pub has_active_chat: Option<bool>,
2509 pub query: Option<String>,
2510 pub visibility: Option<String>,
2513}
2514
2515impl GetGroupsHierarchiesQuery {
2516 pub(crate) fn to_query(&self) -> Query {
2517 let mut q = Query::new();
2518 self.limit.push_query("limit", &mut q);
2519 self.ids.push_query("ids[]", &mut q);
2520 self.campus_ids.push_query("campus_ids[]", &mut q);
2521 self.agegroup_ids.push_query("agegroup_ids[]", &mut q);
2522 self.group_status_ids.push_query("group_status_ids[]", &mut q);
2523 self.group_category_ids.push_query("group_category_ids[]", &mut q);
2524 self.target_group_ids.push_query("target_group_ids[]", &mut q);
2525 self.weekdays.push_query("weekdays[]", &mut q);
2526 self.group_type_ids.push_query("group_type_ids[]", &mut q);
2527 self.tag_ids.push_query("tag_ids[]", &mut q);
2528 self.is_open_for_members.push_query("is_open_for_members", &mut q);
2529 self.without_my_groups.push_query("without_my_groups", &mut q);
2530 self.only_my_groups.push_query("only_my_groups", &mut q);
2531 self.has_meeting_place.push_query("has_meeting_place", &mut q);
2532 self.allow_posts.push_query("allow_posts", &mut q);
2533 self.has_posts.push_query("has_posts", &mut q);
2534 self.has_active_chat.push_query("has_active_chat", &mut q);
2535 self.query.push_query("query", &mut q);
2536 self.visibility.push_query("visibility", &mut q);
2537 q
2538 }
2539}
2540
2541#[derive(Debug, Clone, Default)]
2543pub struct GetGroupsIdsQuery {
2544 pub limit: Option<i64>,
2546 pub ids: Option<Vec<i64>>,
2548 pub parent_id: Option<i64>,
2550 pub child_id: Option<i64>,
2552 pub campus_ids: Option<Vec<i64>>,
2554 pub agegroup_ids: Option<Vec<i64>>,
2556 pub group_status_ids: Option<Vec<i64>>,
2558 pub group_category_ids: Option<Vec<i64>>,
2560 pub target_group_ids: Option<Vec<i64>>,
2562 pub weekdays: Option<Vec<i64>>,
2564 pub group_type_ids: Option<Vec<i64>>,
2566 pub tag_ids: Option<Vec<i64>>,
2568 pub is_open_for_members: Option<bool>,
2570 pub without_my_groups: Option<bool>,
2572 pub only_my_groups: Option<bool>,
2574 pub has_meeting_place: Option<bool>,
2576 pub allow_posts: Option<bool>,
2578 pub has_posts: Option<bool>,
2580 pub has_active_chat: Option<bool>,
2582 pub query: Option<String>,
2583 pub visibility: Option<String>,
2586}
2587
2588impl GetGroupsIdsQuery {
2589 pub(crate) fn to_query(&self) -> Query {
2590 let mut q = Query::new();
2591 self.limit.push_query("limit", &mut q);
2592 self.ids.push_query("ids[]", &mut q);
2593 self.parent_id.push_query("parent_id", &mut q);
2594 self.child_id.push_query("child_id", &mut q);
2595 self.campus_ids.push_query("campus_ids[]", &mut q);
2596 self.agegroup_ids.push_query("agegroup_ids[]", &mut q);
2597 self.group_status_ids.push_query("group_status_ids[]", &mut q);
2598 self.group_category_ids.push_query("group_category_ids[]", &mut q);
2599 self.target_group_ids.push_query("target_group_ids[]", &mut q);
2600 self.weekdays.push_query("weekdays[]", &mut q);
2601 self.group_type_ids.push_query("group_type_ids[]", &mut q);
2602 self.tag_ids.push_query("tag_ids[]", &mut q);
2603 self.is_open_for_members.push_query("is_open_for_members", &mut q);
2604 self.without_my_groups.push_query("without_my_groups", &mut q);
2605 self.only_my_groups.push_query("only_my_groups", &mut q);
2606 self.has_meeting_place.push_query("has_meeting_place", &mut q);
2607 self.allow_posts.push_query("allow_posts", &mut q);
2608 self.has_posts.push_query("has_posts", &mut q);
2609 self.has_active_chat.push_query("has_active_chat", &mut q);
2610 self.query.push_query("query", &mut q);
2611 self.visibility.push_query("visibility", &mut q);
2612 q
2613 }
2614}
2615
2616#[derive(Debug, Clone, Default)]
2618pub struct GetGroupsGroupIdMemberidsQuery {
2619 pub role_ids: Option<Vec<i64>>,
2621 pub person_id: Option<Vec<i64>>,
2623 pub group_member_statuses: Option<Vec<String>>,
2626 pub allowed_chat_users_only: Option<bool>,
2628 pub allowed_chat_writers_only: Option<bool>,
2630 pub query: Option<String>,
2632 pub comment: Option<String>,
2634 pub member_start_date_after: Option<serde_json::Value>,
2636 pub member_start_date_before: Option<serde_json::Value>,
2638}
2639
2640impl GetGroupsGroupIdMemberidsQuery {
2641 pub(crate) fn to_query(&self) -> Query {
2642 let mut q = Query::new();
2643 self.role_ids.push_query("role_ids[]", &mut q);
2644 self.person_id.push_query("person_id[]", &mut q);
2645 self.group_member_statuses.push_query("group_member_statuses[]", &mut q);
2646 self.allowed_chat_users_only.push_query("allowed_chat_users_only", &mut q);
2647 self.allowed_chat_writers_only.push_query("allowed_chat_writers_only", &mut q);
2648 self.query.push_query("query", &mut q);
2649 self.comment.push_query("comment", &mut q);
2650 self.member_start_date_after.push_query("member_start_date_after", &mut q);
2651 self.member_start_date_before.push_query("member_start_date_before", &mut q);
2652 q
2653 }
2654}
2655
2656#[derive(Debug, Clone, Default)]
2658pub struct GetGroupsGroupIdMemberpreviewQuery {
2659 pub members_per_role: Option<i64>,
2661}
2662
2663impl GetGroupsGroupIdMemberpreviewQuery {
2664 pub(crate) fn to_query(&self) -> Query {
2665 let mut q = Query::new();
2666 self.members_per_role.push_query("members_per_role", &mut q);
2667 q
2668 }
2669}
2670
2671#[derive(Debug, Clone, Default)]
2673pub struct GetGroupsMembersQuery {
2674 pub ids: Option<Vec<i64>>,
2676 pub with_deleted: Option<bool>,
2678}
2679
2680impl GetGroupsMembersQuery {
2681 pub(crate) fn to_query(&self) -> Query {
2682 let mut q = Query::new();
2683 self.ids.push_query("ids[]", &mut q);
2684 self.with_deleted.push_query("with_deleted", &mut q);
2685 q
2686 }
2687}
2688
2689#[derive(Debug, Clone, Default)]
2691pub struct GetGroupsGroupIdPostsQuery {
2692 pub before: Option<chrono::DateTime<chrono::Utc>>,
2694 pub last_post_identifier: Option<String>,
2696 pub after: Option<chrono::DateTime<chrono::Utc>>,
2698 pub limit: Option<i64>,
2700 pub include: Option<Vec<String>>,
2703}
2704
2705impl GetGroupsGroupIdPostsQuery {
2706 pub(crate) fn to_query(&self) -> Query {
2707 let mut q = Query::new();
2708 self.before.push_query("before", &mut q);
2709 self.last_post_identifier.push_query("last_post_identifier", &mut q);
2710 self.after.push_query("after", &mut q);
2711 self.limit.push_query("limit", &mut q);
2712 self.include.push_query("include[]", &mut q);
2713 q
2714 }
2715}
2716
2717#[derive(Debug, Clone, Default)]
2719pub struct PostGroupsGroupIdNotificationQuery {
2720 pub dry_run: Option<bool>,
2722}
2723
2724impl PostGroupsGroupIdNotificationQuery {
2725 pub(crate) fn to_query(&self) -> Query {
2726 let mut q = Query::new();
2727 self.dry_run.push_query("dry_run", &mut q);
2728 q
2729 }
2730}
2731
2732#[derive(Debug, Clone, Default)]
2734pub struct PatchGroupsIdQuery {
2735 pub skip_my_posts_reducing_visibility: Option<bool>,
2737 pub deactivate_routines_on_status_finished: Option<bool>,
2739}
2740
2741impl PatchGroupsIdQuery {
2742 pub(crate) fn to_query(&self) -> Query {
2743 let mut q = Query::new();
2744 self.skip_my_posts_reducing_visibility.push_query("skip_my_posts_reducing_visibility", &mut q);
2745 self.deactivate_routines_on_status_finished.push_query("deactivate_routines_on_status_finished", &mut q);
2746 q
2747 }
2748}
2749
2750#[derive(Debug, Clone, Default)]
2752pub struct GetGroupsGroupIdFollowupsQuery {
2753 pub filter: Option<Vec<String>>,
2756 pub limit: Option<i64>,
2758}
2759
2760impl GetGroupsGroupIdFollowupsQuery {
2761 pub(crate) fn to_query(&self) -> Query {
2762 let mut q = Query::new();
2763 self.filter.push_query("filter[]", &mut q);
2764 self.limit.push_query("limit", &mut q);
2765 q
2766 }
2767}
2768
2769#[derive(Debug, Clone, Default)]
2771pub struct GetGroupsGroupIdMeetingsExportQuery {
2772 pub format: Option<String>,
2775 pub r#type: Option<String>,
2778 pub is_canceled: Option<bool>,
2780 pub is_completed: Option<bool>,
2782 pub from: Option<String>,
2784 pub to: Option<String>,
2786 pub direction: Option<String>,
2789}
2790
2791impl GetGroupsGroupIdMeetingsExportQuery {
2792 pub(crate) fn to_query(&self) -> Query {
2793 let mut q = Query::new();
2794 self.format.push_query("format", &mut q);
2795 self.r#type.push_query("type", &mut q);
2796 self.is_canceled.push_query("is_canceled", &mut q);
2797 self.is_completed.push_query("is_completed", &mut q);
2798 self.from.push_query("from", &mut q);
2799 self.to.push_query("to", &mut q);
2800 self.direction.push_query("direction", &mut q);
2801 q
2802 }
2803}
2804
2805#[derive(Debug, Clone, Default)]
2807pub struct GetGroupsIdMeetingsQuery {
2808 pub is_canceled: Option<bool>,
2810 pub is_completed: Option<bool>,
2812 pub from: Option<String>,
2814 pub to: Option<String>,
2816 pub direction: Option<String>,
2819 pub limit: Option<i64>,
2821 pub include: Option<Vec<String>>,
2824}
2825
2826impl GetGroupsIdMeetingsQuery {
2827 pub(crate) fn to_query(&self) -> Query {
2828 let mut q = Query::new();
2829 self.is_canceled.push_query("is_canceled", &mut q);
2830 self.is_completed.push_query("is_completed", &mut q);
2831 self.from.push_query("from", &mut q);
2832 self.to.push_query("to", &mut q);
2833 self.direction.push_query("direction", &mut q);
2834 self.limit.push_query("limit", &mut q);
2835 self.include.push_query("include[]", &mut q);
2836 q
2837 }
2838}
2839
2840#[derive(Debug, Clone, Default)]
2842pub struct PostGroupsIdMembersExportQuery {
2843 pub format: Option<String>,
2846 #[deprecated = "Use `format`"]
2849 pub r#type: Option<String>,
2850}
2851
2852impl PostGroupsIdMembersExportQuery {
2853 pub(crate) fn to_query(&self) -> Query {
2854 let mut q = Query::new();
2855 self.format.push_query("format", &mut q);
2856 self.r#type.push_query("type", &mut q);
2857 q
2858 }
2859}
2860
2861#[derive(Debug, Clone, Default)]
2863pub struct GetGroupsGroupIdMembersExportQuery {
2864 pub format: Option<String>,
2867 #[deprecated = "Use `format`"]
2870 pub r#type: Option<String>,
2871}
2872
2873impl GetGroupsGroupIdMembersExportQuery {
2874 pub(crate) fn to_query(&self) -> Query {
2875 let mut q = Query::new();
2876 self.format.push_query("format", &mut q);
2877 self.r#type.push_query("type", &mut q);
2878 q
2879 }
2880}
2881
2882#[derive(Debug, Clone, Default)]
2884pub struct GetGroupsIdMembersQuery {
2885 pub limit: Option<i64>,
2887 pub role_ids: Option<Vec<i64>>,
2889 pub person_id: Option<Vec<i64>>,
2891 pub group_member_statuses: Option<Vec<String>>,
2894 pub allowed_chat_users_only: Option<bool>,
2896 pub allowed_chat_writers_only: Option<bool>,
2898 pub query: Option<String>,
2900 pub comment: Option<String>,
2902 pub member_start_date_after: Option<serde_json::Value>,
2904 pub member_start_date_before: Option<serde_json::Value>,
2906 pub order_fields: Option<Vec<String>>,
2908 pub order_directions: Option<Vec<String>>,
2911 pub person_fields: Option<Vec<String>>,
2913 pub include: Option<Vec<String>>,
2916}
2917
2918impl GetGroupsIdMembersQuery {
2919 pub(crate) fn to_query(&self) -> Query {
2920 let mut q = Query::new();
2921 self.limit.push_query("limit", &mut q);
2922 self.role_ids.push_query("role_ids[]", &mut q);
2923 self.person_id.push_query("person_id[]", &mut q);
2924 self.group_member_statuses.push_query("group_member_statuses[]", &mut q);
2925 self.allowed_chat_users_only.push_query("allowed_chat_users_only", &mut q);
2926 self.allowed_chat_writers_only.push_query("allowed_chat_writers_only", &mut q);
2927 self.query.push_query("query", &mut q);
2928 self.comment.push_query("comment", &mut q);
2929 self.member_start_date_after.push_query("member_start_date_after", &mut q);
2930 self.member_start_date_before.push_query("member_start_date_before", &mut q);
2931 self.order_fields.push_query("orderFields[]", &mut q);
2932 self.order_directions.push_query("orderDirections[]", &mut q);
2933 self.person_fields.push_query("personFields[]", &mut q);
2934 self.include.push_query("include[]", &mut q);
2935 q
2936 }
2937}
2938
2939#[derive(Debug, Clone, Default)]
2941pub struct GetGroupsGroupIdMembersHistoryQuery {
2942 pub member_id: Option<i64>,
2944 pub actor_id: Option<i64>,
2946 pub origin: Option<String>,
2949 pub new_role_id: Option<i64>,
2951 pub new_status: Option<String>,
2953 pub new_fields: Option<bool>,
2955 #[deprecated = "deprecated in the ChurchTools API"]
2957 pub has_field_changed: Option<bool>,
2958 pub offset_id: Option<i64>,
2960 pub limit: Option<i64>,
2962}
2963
2964impl GetGroupsGroupIdMembersHistoryQuery {
2965 pub(crate) fn to_query(&self) -> Query {
2966 let mut q = Query::new();
2967 self.member_id.push_query("member_id", &mut q);
2968 self.actor_id.push_query("actor_id", &mut q);
2969 self.origin.push_query("origin", &mut q);
2970 self.new_role_id.push_query("new_role_id", &mut q);
2971 self.new_status.push_query("new_status", &mut q);
2972 self.new_fields.push_query("new_fields", &mut q);
2973 self.has_field_changed.push_query("has_field_changed", &mut q);
2974 self.offset_id.push_query("offset_id", &mut q);
2975 self.limit.push_query("limit", &mut q);
2976 q
2977 }
2978}
2979
2980#[derive(Debug, Clone, Default)]
2982pub struct GetGroupsGroupIdMembersStatisticsQuery {
2983 pub group_type_role_ids: Option<Vec<i64>>,
2985 pub person_fields: Option<Vec<String>>,
2987 pub group_member_fields: Option<Vec<i64>>,
2989}
2990
2991impl GetGroupsGroupIdMembersStatisticsQuery {
2992 pub(crate) fn to_query(&self) -> Query {
2993 let mut q = Query::new();
2994 self.group_type_role_ids.push_query("group_type_role_ids[]", &mut q);
2995 self.person_fields.push_query("personFields[]", &mut q);
2996 self.group_member_fields.push_query("groupMemberFields[]", &mut q);
2997 q
2998 }
2999}
3000
3001#[derive(Debug, Clone, Default)]
3003pub struct GetGroupsGroupIdMembersPersonIdFollowupsQuery {
3004 pub filter: Option<Vec<String>>,
3007 pub limit: Option<i64>,
3009}
3010
3011impl GetGroupsGroupIdMembersPersonIdFollowupsQuery {
3012 pub(crate) fn to_query(&self) -> Query {
3013 let mut q = Query::new();
3014 self.filter.push_query("filter[]", &mut q);
3015 self.limit.push_query("limit", &mut q);
3016 q
3017 }
3018}
3019
3020#[derive(Debug, Clone, Default)]
3022pub struct PostGroupsGroupIdNewsletterIntegrationsProviderListIdResendOptinsQuery {
3023 pub person_id: Option<i64>,
3025}
3026
3027impl PostGroupsGroupIdNewsletterIntegrationsProviderListIdResendOptinsQuery {
3028 pub(crate) fn to_query(&self) -> Query {
3029 let mut q = Query::new();
3030 self.person_id.push_query("person_id", &mut q);
3031 q
3032 }
3033}
3034
3035#[derive(Debug, Clone, Default)]
3037pub struct GetGroupsGroupIdParentsQuery {
3038 pub limit: Option<i64>,
3040 pub ids: Option<Vec<i64>>,
3042 pub campus_ids: Option<Vec<i64>>,
3044 pub agegroup_ids: Option<Vec<i64>>,
3046 pub group_status_ids: Option<Vec<i64>>,
3048 pub group_category_ids: Option<Vec<i64>>,
3050 pub target_group_ids: Option<Vec<i64>>,
3052 pub weekdays: Option<Vec<i64>>,
3054 pub group_type_ids: Option<Vec<i64>>,
3056 pub tag_ids: Option<Vec<i64>>,
3058 pub is_open_for_members: Option<bool>,
3060 pub without_my_groups: Option<bool>,
3062 pub only_my_groups: Option<bool>,
3064 pub has_meeting_place: Option<bool>,
3066 pub allow_posts: Option<bool>,
3068 pub has_posts: Option<bool>,
3070 pub has_active_chat: Option<bool>,
3072 pub query: Option<String>,
3073 pub visibility: Option<String>,
3076}
3077
3078impl GetGroupsGroupIdParentsQuery {
3079 pub(crate) fn to_query(&self) -> Query {
3080 let mut q = Query::new();
3081 self.limit.push_query("limit", &mut q);
3082 self.ids.push_query("ids[]", &mut q);
3083 self.campus_ids.push_query("campus_ids[]", &mut q);
3084 self.agegroup_ids.push_query("agegroup_ids[]", &mut q);
3085 self.group_status_ids.push_query("group_status_ids[]", &mut q);
3086 self.group_category_ids.push_query("group_category_ids[]", &mut q);
3087 self.target_group_ids.push_query("target_group_ids[]", &mut q);
3088 self.weekdays.push_query("weekdays[]", &mut q);
3089 self.group_type_ids.push_query("group_type_ids[]", &mut q);
3090 self.tag_ids.push_query("tag_ids[]", &mut q);
3091 self.is_open_for_members.push_query("is_open_for_members", &mut q);
3092 self.without_my_groups.push_query("without_my_groups", &mut q);
3093 self.only_my_groups.push_query("only_my_groups", &mut q);
3094 self.has_meeting_place.push_query("has_meeting_place", &mut q);
3095 self.allow_posts.push_query("allow_posts", &mut q);
3096 self.has_posts.push_query("has_posts", &mut q);
3097 self.has_active_chat.push_query("has_active_chat", &mut q);
3098 self.query.push_query("query", &mut q);
3099 self.visibility.push_query("visibility", &mut q);
3100 q
3101 }
3102}
3103
3104#[derive(Debug, Clone, Default)]
3106pub struct GetGroupsIdWikiCategoriesPagesQuery {
3107 pub limit: Option<i64>,
3109}
3110
3111impl GetGroupsIdWikiCategoriesPagesQuery {
3112 pub(crate) fn to_query(&self) -> Query {
3113 let mut q = Query::new();
3114 self.limit.push_query("limit", &mut q);
3115 q
3116 }
3117}
3118
3119#[derive(Debug, Clone, Default)]
3121pub struct GetHistoryQuery {
3122 pub domain_types: Option<Vec<String>>,
3124 pub domain_identifiers: Option<Vec<String>>,
3126 pub action: Option<String>,
3128 pub query: Option<String>,
3130 pub from: Option<chrono::NaiveDate>,
3132 pub to: Option<chrono::NaiveDate>,
3134 pub actor_id: Option<i64>,
3136 pub origin: Option<String>,
3138 pub limit: Option<i64>,
3140}
3141
3142impl GetHistoryQuery {
3143 pub(crate) fn to_query(&self) -> Query {
3144 let mut q = Query::new();
3145 self.domain_types.push_query("domain_types[]", &mut q);
3146 self.domain_identifiers.push_query("domain_identifiers[]", &mut q);
3147 self.action.push_query("action", &mut q);
3148 self.query.push_query("query", &mut q);
3149 self.from.push_query("from", &mut q);
3150 self.to.push_query("to", &mut q);
3151 self.actor_id.push_query("actor_id", &mut q);
3152 self.origin.push_query("origin", &mut q);
3153 self.limit.push_query("limit", &mut q);
3154 q
3155 }
3156}
3157
3158#[derive(Debug, Clone, Default)]
3160pub struct DeleteHtmltemplatesTemplateIdQuery {
3161 pub dry_run: Option<bool>,
3163}
3164
3165impl DeleteHtmltemplatesTemplateIdQuery {
3166 pub(crate) fn to_query(&self) -> Query {
3167 let mut q = Query::new();
3168 self.dry_run.push_query("dryRun", &mut q);
3169 q
3170 }
3171}
3172
3173#[derive(Debug, Clone, Default)]
3175pub struct GetHtmltemplatesQuery {
3176 pub domain_type: Option<String>,
3179 #[deprecated = "deprecated in the ChurchTools API"]
3182 pub r#type: Option<String>,
3183 pub only_own: Option<bool>,
3185}
3186
3187impl GetHtmltemplatesQuery {
3188 pub(crate) fn to_query(&self) -> Query {
3189 let mut q = Query::new();
3190 self.domain_type.push_query("domain_type", &mut q);
3191 self.r#type.push_query("type", &mut q);
3192 self.only_own.push_query("onlyOwn", &mut q);
3193 q
3194 }
3195}
3196
3197#[derive(Debug, Clone, Default)]
3199pub struct GetImagesFileIdHashQuery {
3200 pub w: Option<String>,
3202 pub h: Option<String>,
3204 pub q: Option<i64>,
3206 pub crop: Option<String>,
3208 pub fit: Option<String>,
3210 pub fm: Option<String>,
3213 pub p: Option<String>,
3215}
3216
3217impl GetImagesFileIdHashQuery {
3218 pub(crate) fn to_query(&self) -> Query {
3219 let mut q = Query::new();
3220 self.w.push_query("w", &mut q);
3221 self.h.push_query("h", &mut q);
3222 self.q.push_query("q", &mut q);
3223 self.crop.push_query("crop", &mut q);
3224 self.fit.push_query("fit", &mut q);
3225 self.fm.push_query("fm", &mut q);
3226 self.p.push_query("p", &mut q);
3227 q
3228 }
3229}
3230
3231#[derive(Debug, Clone, Default)]
3233pub struct GetJoblogQuery {
3234 pub guid: Option<String>,
3236}
3237
3238impl GetJoblogQuery {
3239 pub(crate) fn to_query(&self) -> Query {
3240 let mut q = Query::new();
3241 self.guid.push_query("guid", &mut q);
3242 q
3243 }
3244}
3245
3246#[derive(Debug, Clone, Default)]
3248pub struct GetJobsQuery {
3249 pub status: Option<Vec<String>>,
3252 pub identifier: Option<String>,
3254 pub name: Option<String>,
3256 pub domain_ids: Option<Vec<f64>>,
3258 pub created_start_date: Option<chrono::NaiveDate>,
3260 pub created_end_date: Option<chrono::NaiveDate>,
3262 pub modified_start_date: Option<chrono::NaiveDate>,
3264 pub modified_end_date: Option<chrono::NaiveDate>,
3266}
3267
3268impl GetJobsQuery {
3269 pub(crate) fn to_query(&self) -> Query {
3270 let mut q = Query::new();
3271 self.status.push_query("status[]", &mut q);
3272 self.identifier.push_query("identifier", &mut q);
3273 self.name.push_query("name", &mut q);
3274 self.domain_ids.push_query("domain_ids[]", &mut q);
3275 self.created_start_date.push_query("created_start_date", &mut q);
3276 self.created_end_date.push_query("created_end_date", &mut q);
3277 self.modified_start_date.push_query("modified_start_date", &mut q);
3278 self.modified_end_date.push_query("modified_end_date", &mut q);
3279 q
3280 }
3281}
3282
3283#[derive(Debug, Clone, Default)]
3285pub struct GetLanguagesQuery {
3286 pub only_active: Option<bool>,
3288}
3289
3290impl GetLanguagesQuery {
3291 pub(crate) fn to_query(&self) -> Query {
3292 let mut q = Query::new();
3293 self.only_active.push_query("only_active", &mut q);
3294 q
3295 }
3296}
3297
3298#[derive(Debug, Clone, Default)]
3300pub struct GetLogsQuery {
3301 pub message: Option<String>,
3303 pub levels: Option<Vec<String>>,
3305 pub before: Option<String>,
3307 pub after: Option<String>,
3309 pub person_id: Option<i64>,
3311 pub limit: Option<i64>,
3313}
3314
3315impl GetLogsQuery {
3316 pub(crate) fn to_query(&self) -> Query {
3317 let mut q = Query::new();
3318 self.message.push_query("message", &mut q);
3319 self.levels.push_query("levels[]", &mut q);
3320 self.before.push_query("before", &mut q);
3321 self.after.push_query("after", &mut q);
3322 self.person_id.push_query("person_id", &mut q);
3323 self.limit.push_query("limit", &mut q);
3324 q
3325 }
3326}
3327
3328#[derive(Debug, Clone, Default)]
3330pub struct GetLogsStatisticsLoginQuery {
3331 pub order_by: Option<String>,
3333 pub limit: Option<i64>,
3335}
3336
3337impl GetLogsStatisticsLoginQuery {
3338 pub(crate) fn to_query(&self) -> Query {
3339 let mut q = Query::new();
3340 self.order_by.push_query("order_by", &mut q);
3341 self.limit.push_query("limit", &mut q);
3342 q
3343 }
3344}
3345
3346#[derive(Debug, Clone, Default)]
3348pub struct GetPermissionsDefinitionsQuery {
3349 pub scope: Option<String>,
3352}
3353
3354impl GetPermissionsDefinitionsQuery {
3355 pub(crate) fn to_query(&self) -> Query {
3356 let mut q = Query::new();
3357 self.scope.push_query("scope", &mut q);
3358 q
3359 }
3360}
3361
3362#[derive(Debug, Clone, Default)]
3364pub struct GetPermissionsAssignmentTargetsQuery {
3365 pub query: Option<String>,
3367 pub domain_types: Option<Vec<String>>,
3370 pub group_id: Option<i64>,
3372 pub limit: Option<i64>,
3374}
3375
3376impl GetPermissionsAssignmentTargetsQuery {
3377 pub(crate) fn to_query(&self) -> Query {
3378 let mut q = Query::new();
3379 self.query.push_query("query", &mut q);
3380 self.domain_types.push_query("domainTypes[]", &mut q);
3381 self.group_id.push_query("groupId", &mut q);
3382 self.limit.push_query("limit", &mut q);
3383 q
3384 }
3385}
3386
3387#[derive(Debug, Clone, Default)]
3389pub struct GetPermissionsPermissionDomainTypeQuery {
3390 pub domain_id: Option<i64>,
3392}
3393
3394impl GetPermissionsPermissionDomainTypeQuery {
3395 pub(crate) fn to_query(&self) -> Query {
3396 let mut q = Query::new();
3397 self.domain_id.push_query("domainId", &mut q);
3398 q
3399 }
3400}
3401
3402#[derive(Debug, Clone, Default)]
3404pub struct GetPermissionsGlobalAuthsAuthIdAssignmentSummaryQuery {
3405 pub data_id: Option<i64>,
3407}
3408
3409impl GetPermissionsGlobalAuthsAuthIdAssignmentSummaryQuery {
3410 pub(crate) fn to_query(&self) -> Query {
3411 let mut q = Query::new();
3412 self.data_id.push_query("data_id", &mut q);
3413 q
3414 }
3415}
3416
3417#[derive(Debug, Clone, Default)]
3419pub struct GetPermissionsGlobalAuthsAuthIdPersonsQuery {
3420 pub data_id: Option<i64>,
3422 pub page: Option<i64>,
3424 pub limit: Option<i64>,
3426 pub include: Option<String>,
3429}
3430
3431impl GetPermissionsGlobalAuthsAuthIdPersonsQuery {
3432 pub(crate) fn to_query(&self) -> Query {
3433 let mut q = Query::new();
3434 self.data_id.push_query("data_id", &mut q);
3435 self.page.push_query("page", &mut q);
3436 self.limit.push_query("limit", &mut q);
3437 self.include.push_query("include", &mut q);
3438 q
3439 }
3440}
3441
3442#[derive(Debug, Clone, Default)]
3444pub struct GetPermissionsInternalGroupsGroupIdAuthsAuthIdPersonsQuery {
3445 pub data_id: Option<i64>,
3447}
3448
3449impl GetPermissionsInternalGroupsGroupIdAuthsAuthIdPersonsQuery {
3450 pub(crate) fn to_query(&self) -> Query {
3451 let mut q = Query::new();
3452 self.data_id.push_query("data_id", &mut q);
3453 q
3454 }
3455}
3456
3457#[derive(Debug, Clone, Default)]
3459pub struct GetPermissionsOriginsInternalPersonsPersonIdQuery {
3460 pub group_ids: Option<Vec<i64>>,
3462}
3463
3464impl GetPermissionsOriginsInternalPersonsPersonIdQuery {
3465 pub(crate) fn to_query(&self) -> Query {
3466 let mut q = Query::new();
3467 self.group_ids.push_query("group_ids[]", &mut q);
3468 q
3469 }
3470}
3471
3472#[derive(Debug, Clone, Default)]
3474pub struct DeletePersonCommentviewersIdQuery {
3475 pub dry_run: Option<bool>,
3477}
3478
3479impl DeletePersonCommentviewersIdQuery {
3480 pub(crate) fn to_query(&self) -> Query {
3481 let mut q = Query::new();
3482 self.dry_run.push_query("dry_run", &mut q);
3483 q
3484 }
3485}
3486
3487#[derive(Debug, Clone, Default)]
3489pub struct DeletePersonGrowpathsIdQuery {
3490 pub dry_run: Option<bool>,
3492}
3493
3494impl DeletePersonGrowpathsIdQuery {
3495 pub(crate) fn to_query(&self) -> Query {
3496 let mut q = Query::new();
3497 self.dry_run.push_query("dryRun", &mut q);
3498 q
3499 }
3500}
3501
3502#[derive(Debug, Clone, Default)]
3504pub struct DeletePersonRelationshiptypesIdQuery {
3505 pub dry_run: Option<bool>,
3507}
3508
3509impl DeletePersonRelationshiptypesIdQuery {
3510 pub(crate) fn to_query(&self) -> Query {
3511 let mut q = Query::new();
3512 self.dry_run.push_query("dryRun", &mut q);
3513 q
3514 }
3515}
3516
3517#[derive(Debug, Clone, Default)]
3519pub struct DeletePersonSexesIdQuery {
3520 pub dry_run: Option<bool>,
3522}
3523
3524impl DeletePersonSexesIdQuery {
3525 pub(crate) fn to_query(&self) -> Query {
3526 let mut q = Query::new();
3527 self.dry_run.push_query("dry_run", &mut q);
3528 q
3529 }
3530}
3531
3532#[derive(Debug, Clone, Default)]
3534pub struct PostPersonsQuery {
3535 pub force: Option<bool>,
3537 pub without_privacy_policy_agreement: Option<bool>,
3539}
3540
3541impl PostPersonsQuery {
3542 pub(crate) fn to_query(&self) -> Query {
3543 let mut q = Query::new();
3544 self.force.push_query("force", &mut q);
3545 self.without_privacy_policy_agreement.push_query("without_privacy_policy_agreement", &mut q);
3546 q
3547 }
3548}
3549
3550#[derive(Debug, Clone, Default)]
3552pub struct PostPersonsFilterQuery {
3553 pub page: Option<i64>,
3555 pub limit: Option<i64>,
3557}
3558
3559impl PostPersonsFilterQuery {
3560 pub(crate) fn to_query(&self) -> Query {
3561 let mut q = Query::new();
3562 self.page.push_query("page", &mut q);
3563 self.limit.push_query("limit", &mut q);
3564 q
3565 }
3566}
3567
3568#[derive(Debug, Clone, Default)]
3570pub struct GetPersonsQuery {
3571 pub ids: Option<Vec<i64>>,
3573 pub status_ids: Option<Vec<i64>>,
3575 pub campus_ids: Option<Vec<i64>>,
3577 pub birthday_before: Option<chrono::NaiveDate>,
3579 pub birthday_after: Option<chrono::NaiveDate>,
3581 pub is_archived: Option<bool>,
3583 pub is_account_locked: Option<bool>,
3585 pub is_system_user: Option<bool>,
3587 pub first_name: Option<String>,
3589 pub nick_name: Option<String>,
3591 pub last_name: Option<String>,
3593 pub query: Option<String>,
3595 pub email: Option<String>,
3597 pub email_exact: Option<String>,
3599 pub limit: Option<i64>,
3601 pub include: Option<Vec<String>>,
3604}
3605
3606impl GetPersonsQuery {
3607 pub(crate) fn to_query(&self) -> Query {
3608 let mut q = Query::new();
3609 self.ids.push_query("ids[]", &mut q);
3610 self.status_ids.push_query("status_ids[]", &mut q);
3611 self.campus_ids.push_query("campus_ids[]", &mut q);
3612 self.birthday_before.push_query("birthday_before", &mut q);
3613 self.birthday_after.push_query("birthday_after", &mut q);
3614 self.is_archived.push_query("is_archived", &mut q);
3615 self.is_account_locked.push_query("is_account_locked", &mut q);
3616 self.is_system_user.push_query("is_system_user", &mut q);
3617 self.first_name.push_query("firstName", &mut q);
3618 self.nick_name.push_query("nickName", &mut q);
3619 self.last_name.push_query("lastName", &mut q);
3620 self.query.push_query("query", &mut q);
3621 self.email.push_query("email", &mut q);
3622 self.email_exact.push_query("email-exact", &mut q);
3623 self.limit.push_query("limit", &mut q);
3624 self.include.push_query("include[]", &mut q);
3625 q
3626 }
3627}
3628
3629#[derive(Debug, Clone, Default)]
3631pub struct GetPersonsBirthdaysQuery {
3632 pub start_date: Option<chrono::NaiveDate>,
3634 pub end_date: Option<chrono::NaiveDate>,
3636 pub direction: Option<String>,
3639 pub limit: Option<i64>,
3641 pub campus_ids: Option<Vec<i64>>,
3643 pub group_ids: Option<Vec<i64>>,
3645 pub my_groups: Option<bool>,
3647 pub status_ids: Option<Vec<i64>>,
3649}
3650
3651impl GetPersonsBirthdaysQuery {
3652 pub(crate) fn to_query(&self) -> Query {
3653 let mut q = Query::new();
3654 self.start_date.push_query("start_date", &mut q);
3655 self.end_date.push_query("end_date", &mut q);
3656 self.direction.push_query("direction", &mut q);
3657 self.limit.push_query("limit", &mut q);
3658 self.campus_ids.push_query("campus_ids[]", &mut q);
3659 self.group_ids.push_query("group_ids[]", &mut q);
3660 self.my_groups.push_query("my_groups", &mut q);
3661 self.status_ids.push_query("status_ids[]", &mut q);
3662 q
3663 }
3664}
3665
3666#[derive(Debug, Clone, Default)]
3668pub struct GetPersonsDuplicatesQuery {
3669 pub reset_cache: Option<bool>,
3670}
3671
3672impl GetPersonsDuplicatesQuery {
3673 pub(crate) fn to_query(&self) -> Query {
3674 let mut q = Query::new();
3675 self.reset_cache.push_query("reset_cache", &mut q);
3676 q
3677 }
3678}
3679
3680#[derive(Debug, Clone, Default)]
3682pub struct GetPersonsIdGroupsQuery {
3683 pub show_overdue_groups: Option<bool>,
3685 pub show_inactive_groups: Option<bool>,
3687 pub show_to_delete_memberships: Option<bool>,
3689 pub show_requested_or_waiting_memberships: Option<bool>,
3691}
3692
3693impl GetPersonsIdGroupsQuery {
3694 pub(crate) fn to_query(&self) -> Query {
3695 let mut q = Query::new();
3696 self.show_overdue_groups.push_query("show_overdue_groups", &mut q);
3697 self.show_inactive_groups.push_query("show_inactive_groups", &mut q);
3698 self.show_to_delete_memberships.push_query("show_to_delete_memberships", &mut q);
3699 self.show_requested_or_waiting_memberships.push_query("show_requested_or_waiting_memberships", &mut q);
3700 q
3701 }
3702}
3703
3704#[derive(Debug, Clone, Default)]
3706pub struct GetPersonsPersonIdPostsQuery {
3707 pub filter: Option<Vec<String>>,
3710 pub limit: Option<i64>,
3712 pub before: Option<chrono::DateTime<chrono::Utc>>,
3714 pub last_post_indentifier: Option<String>,
3716 pub after: Option<chrono::DateTime<chrono::Utc>>,
3718}
3719
3720impl GetPersonsPersonIdPostsQuery {
3721 pub(crate) fn to_query(&self) -> Query {
3722 let mut q = Query::new();
3723 self.filter.push_query("filter[]", &mut q);
3724 self.limit.push_query("limit", &mut q);
3725 self.before.push_query("before", &mut q);
3726 self.last_post_indentifier.push_query("last_post_indentifier", &mut q);
3727 self.after.push_query("after", &mut q);
3728 q
3729 }
3730}
3731
3732#[derive(Debug, Clone, Default)]
3734pub struct DeletePersonsPersonIdAbsencesIdQuery {
3735 pub dry_run: Option<bool>,
3737}
3738
3739impl DeletePersonsPersonIdAbsencesIdQuery {
3740 pub(crate) fn to_query(&self) -> Query {
3741 let mut q = Query::new();
3742 self.dry_run.push_query("dry_run", &mut q);
3743 q
3744 }
3745}
3746
3747#[derive(Debug, Clone, Default)]
3749pub struct GetPersonsPersonIdAbsencesQuery {
3750 pub from: Option<serde_json::Value>,
3752 pub to: Option<serde_json::Value>,
3754 pub order_direction: Option<String>,
3757}
3758
3759impl GetPersonsPersonIdAbsencesQuery {
3760 pub(crate) fn to_query(&self) -> Query {
3761 let mut q = Query::new();
3762 self.from.push_query("from", &mut q);
3763 self.to.push_query("to", &mut q);
3764 self.order_direction.push_query("order_direction", &mut q);
3765 q
3766 }
3767}
3768
3769#[derive(Debug, Clone, Default)]
3771pub struct GetPersonsIdEventsQuery {
3772 pub from: Option<chrono::NaiveDate>,
3774}
3775
3776impl GetPersonsIdEventsQuery {
3777 pub(crate) fn to_query(&self) -> Query {
3778 let mut q = Query::new();
3779 self.from.push_query("from", &mut q);
3780 q
3781 }
3782}
3783
3784#[derive(Debug, Clone, Default)]
3786pub struct DeletePersonsIdEventsIdServicesIdExchangerequestsIdQuery {
3787 pub hard_delete: Option<bool>,
3789}
3790
3791impl DeletePersonsIdEventsIdServicesIdExchangerequestsIdQuery {
3792 pub(crate) fn to_query(&self) -> Query {
3793 let mut q = Query::new();
3794 self.hard_delete.push_query("hardDelete", &mut q);
3795 q
3796 }
3797}
3798
3799#[derive(Debug, Clone, Default)]
3801pub struct GetPersonsIdEventsIdServicesIdExchangerequestsQuery {
3802 pub incoming: Option<bool>,
3804}
3805
3806impl GetPersonsIdEventsIdServicesIdExchangerequestsQuery {
3807 pub(crate) fn to_query(&self) -> Query {
3808 let mut q = Query::new();
3809 self.incoming.push_query("incoming", &mut q);
3810 q
3811 }
3812}
3813
3814#[derive(Debug, Clone, Default)]
3816pub struct GetPersonsIdExchangerequestsQuery {
3817 pub person_is_requester: Option<bool>,
3819}
3820
3821impl GetPersonsIdExchangerequestsQuery {
3822 pub(crate) fn to_query(&self) -> Query {
3823 let mut q = Query::new();
3824 self.person_is_requester.push_query("personIsRequester", &mut q);
3825 q
3826 }
3827}
3828
3829#[derive(Debug, Clone, Default)]
3831pub struct GetPersonsPersonIdFollowupsQuery {
3832 pub filter: Option<Vec<String>>,
3835 pub limit: Option<i64>,
3837}
3838
3839impl GetPersonsPersonIdFollowupsQuery {
3840 pub(crate) fn to_query(&self) -> Query {
3841 let mut q = Query::new();
3842 self.filter.push_query("filter[]", &mut q);
3843 self.limit.push_query("limit", &mut q);
3844 q
3845 }
3846}
3847
3848#[derive(Debug, Clone, Default)]
3850pub struct DeletePersonsIdServicerequestsIdQuery {
3851 pub comment: Option<String>,
3853}
3854
3855impl DeletePersonsIdServicerequestsIdQuery {
3856 pub(crate) fn to_query(&self) -> Query {
3857 let mut q = Query::new();
3858 self.comment.push_query("comment", &mut q);
3859 q
3860 }
3861}
3862
3863#[derive(Debug, Clone, Default)]
3865pub struct GetPersonsIdServicerequestsQuery {
3866 pub only_future: Option<bool>,
3868 #[deprecated = "deprecated in the ChurchTools API"]
3870 pub get_all_in_future: Option<bool>,
3871}
3872
3873impl GetPersonsIdServicerequestsQuery {
3874 pub(crate) fn to_query(&self) -> Query {
3875 let mut q = Query::new();
3876 self.only_future.push_query("only_future", &mut q);
3877 self.get_all_in_future.push_query("getAllInFuture", &mut q);
3878 q
3879 }
3880}
3881
3882#[derive(Debug, Clone, Default)]
3884pub struct GetPollfornewsQuery {
3885 pub domain_types: Option<Vec<String>>,
3887 pub since: Option<chrono::DateTime<chrono::Utc>>,
3889}
3890
3891impl GetPollfornewsQuery {
3892 pub(crate) fn to_query(&self) -> Query {
3893 let mut q = Query::new();
3894 self.domain_types.push_query("domain_types[]", &mut q);
3895 self.since.push_query("since", &mut q);
3896 q
3897 }
3898}
3899
3900#[derive(Debug, Clone, Default)]
3902pub struct GetPostLinkingsQuery {
3903 pub post_ids: Option<Vec<i64>>,
3905}
3906
3907impl GetPostLinkingsQuery {
3908 pub(crate) fn to_query(&self) -> Query {
3909 let mut q = Query::new();
3910 self.post_ids.push_query("post_ids[]", &mut q);
3911 q
3912 }
3913}
3914
3915#[derive(Debug, Clone, Default)]
3917pub struct GetPostSearchQuery {
3918 pub query: Option<String>,
3920 pub order_by: Option<String>,
3923 pub order_direction: Option<String>,
3926 pub before: Option<chrono::DateTime<chrono::Utc>>,
3928 pub after: Option<chrono::DateTime<chrono::Utc>>,
3930 pub campus_ids: Option<Vec<i64>>,
3932 pub actor_ids: Option<Vec<i64>>,
3934 pub group_visibility: Option<String>,
3937 pub post_visibility: Option<String>,
3940 pub group_ids: Option<Vec<i64>>,
3942 pub include: Option<Vec<String>>,
3945 pub only_my_groups: Option<bool>,
3947}
3948
3949impl GetPostSearchQuery {
3950 pub(crate) fn to_query(&self) -> Query {
3951 let mut q = Query::new();
3952 self.query.push_query("query", &mut q);
3953 self.order_by.push_query("order_by", &mut q);
3954 self.order_direction.push_query("order_direction", &mut q);
3955 self.before.push_query("before", &mut q);
3956 self.after.push_query("after", &mut q);
3957 self.campus_ids.push_query("campus_ids[]", &mut q);
3958 self.actor_ids.push_query("actor_ids[]", &mut q);
3959 self.group_visibility.push_query("group_visibility", &mut q);
3960 self.post_visibility.push_query("post_visibility", &mut q);
3961 self.group_ids.push_query("group_ids[]", &mut q);
3962 self.include.push_query("include[]", &mut q);
3963 self.only_my_groups.push_query("only_my_groups", &mut q);
3964 q
3965 }
3966}
3967
3968#[derive(Debug, Clone, Default)]
3970pub struct GetPostReportsQuery {
3971 pub domain_type: Option<String>,
3973 pub domain_id: Option<i64>,
3974 pub status: Option<String>,
3976}
3977
3978impl GetPostReportsQuery {
3979 pub(crate) fn to_query(&self) -> Query {
3980 let mut q = Query::new();
3981 self.domain_type.push_query("domain_type", &mut q);
3982 self.domain_id.push_query("domain_id", &mut q);
3983 self.status.push_query("status", &mut q);
3984 q
3985 }
3986}
3987
3988#[derive(Debug, Clone, Default)]
3990pub struct DeletePostsPostIdQuery {
3991 pub dry_run: Option<bool>,
3993}
3994
3995impl DeletePostsPostIdQuery {
3996 pub(crate) fn to_query(&self) -> Query {
3997 let mut q = Query::new();
3998 self.dry_run.push_query("dryRun", &mut q);
3999 q
4000 }
4001}
4002
4003#[derive(Debug, Clone, Default)]
4005pub struct GetPostsPostIdQuery {
4006 pub include: Option<Vec<String>>,
4009}
4010
4011impl GetPostsPostIdQuery {
4012 pub(crate) fn to_query(&self) -> Query {
4013 let mut q = Query::new();
4014 self.include.push_query("include[]", &mut q);
4015 q
4016 }
4017}
4018
4019#[derive(Debug, Clone, Default)]
4021pub struct GetPostsQuery {
4022 pub before: Option<chrono::DateTime<chrono::Utc>>,
4024 pub last_post_identifier: Option<String>,
4026 pub after: Option<chrono::DateTime<chrono::Utc>>,
4028 #[deprecated = "deprecated in the ChurchTools API"]
4030 pub campus_id: Option<i64>,
4031 pub campus_ids: Option<Vec<i64>>,
4033 pub actor_ids: Option<Vec<i64>>,
4035 pub group_visibility: Option<String>,
4038 pub post_visibility: Option<String>,
4041 pub group_ids: Option<Vec<i64>>,
4043 pub include: Option<Vec<String>>,
4046 pub limit: Option<i64>,
4048 pub only_my_groups: Option<bool>,
4050}
4051
4052impl GetPostsQuery {
4053 pub(crate) fn to_query(&self) -> Query {
4054 let mut q = Query::new();
4055 self.before.push_query("before", &mut q);
4056 self.last_post_identifier.push_query("last_post_identifier", &mut q);
4057 self.after.push_query("after", &mut q);
4058 self.campus_id.push_query("campus_id", &mut q);
4059 self.campus_ids.push_query("campus_ids[]", &mut q);
4060 self.actor_ids.push_query("actor_ids[]", &mut q);
4061 self.group_visibility.push_query("group_visibility", &mut q);
4062 self.post_visibility.push_query("post_visibility", &mut q);
4063 self.group_ids.push_query("group_ids[]", &mut q);
4064 self.include.push_query("include[]", &mut q);
4065 self.limit.push_query("limit", &mut q);
4066 self.only_my_groups.push_query("only_my_groups", &mut q);
4067 q
4068 }
4069}
4070
4071#[derive(Debug, Clone, Default)]
4073pub struct GetProfilesSlugcheckSlugQuery {
4074 pub guid: Option<String>,
4076}
4077
4078impl GetProfilesSlugcheckSlugQuery {
4079 pub(crate) fn to_query(&self) -> Query {
4080 let mut q = Query::new();
4081 self.guid.push_query("guid", &mut q);
4082 q
4083 }
4084}
4085
4086#[derive(Debug, Clone, Default)]
4088pub struct GetPublicgroupsIdQuery {
4089 pub hash: Option<String>,
4091}
4092
4093impl GetPublicgroupsIdQuery {
4094 pub(crate) fn to_query(&self) -> Query {
4095 let mut q = Query::new();
4096 self.hash.push_query("hash", &mut q);
4097 q
4098 }
4099}
4100
4101#[derive(Debug, Clone, Default)]
4103pub struct GetPublicgroupsGroupIdFormQuery {
4104 pub token: Option<String>,
4106 pub person_id: Option<i64>,
4108}
4109
4110impl GetPublicgroupsGroupIdFormQuery {
4111 pub(crate) fn to_query(&self) -> Query {
4112 let mut q = Query::new();
4113 self.token.push_query("token", &mut q);
4114 self.person_id.push_query("personId", &mut q);
4115 q
4116 }
4117}
4118
4119#[derive(Debug, Clone, Default)]
4121pub struct GetPublicgroupsGroupIdPossiblerequestersQuery {
4122 pub token: Option<String>,
4124}
4125
4126impl GetPublicgroupsGroupIdPossiblerequestersQuery {
4127 pub(crate) fn to_query(&self) -> Query {
4128 let mut q = Query::new();
4129 self.token.push_query("token", &mut q);
4130 q
4131 }
4132}
4133
4134#[derive(Debug, Clone, Default)]
4136pub struct GetPublicgroupsIdSignoutdataQuery {
4137 pub token: Option<String>,
4139}
4140
4141impl GetPublicgroupsIdSignoutdataQuery {
4142 pub(crate) fn to_query(&self) -> Query {
4143 let mut q = Query::new();
4144 self.token.push_query("token", &mut q);
4145 q
4146 }
4147}
4148
4149#[derive(Debug, Clone, Default)]
4151pub struct GetRepeatcalculationQuery {
4152 pub additionals: Option<serde_json::Value>,
4154 pub end_date: Option<serde_json::Value>,
4156 pub exceptions: Option<serde_json::Value>,
4158 pub repeat_frequency: Option<i64>,
4160 pub repeat_id: Option<i64>,
4163 pub repeat_option: Option<i64>,
4165 pub repeat_until: Option<chrono::NaiveDate>,
4167 pub start_date: Option<serde_json::Value>,
4169}
4170
4171impl GetRepeatcalculationQuery {
4172 pub(crate) fn to_query(&self) -> Query {
4173 let mut q = Query::new();
4174 self.additionals.push_query("additionals", &mut q);
4175 self.end_date.push_query("endDate", &mut q);
4176 self.exceptions.push_query("exceptions", &mut q);
4177 self.repeat_frequency.push_query("repeatFrequency", &mut q);
4178 self.repeat_id.push_query("repeatId", &mut q);
4179 self.repeat_option.push_query("repeatOption", &mut q);
4180 self.repeat_until.push_query("repeatUntil", &mut q);
4181 self.start_date.push_query("startDate", &mut q);
4182 q
4183 }
4184}
4185
4186#[derive(Debug, Clone, Default)]
4188pub struct GetResourceMasterdataQuery {
4189 pub include: Option<Vec<String>>,
4192}
4193
4194impl GetResourceMasterdataQuery {
4195 pub(crate) fn to_query(&self) -> Query {
4196 let mut q = Query::new();
4197 self.include.push_query("include[]", &mut q);
4198 q
4199 }
4200}
4201
4202#[derive(Debug, Clone, Default)]
4204pub struct GetResourcesResourceIdQuery {
4205 pub include: Option<Vec<String>>,
4208}
4209
4210impl GetResourcesResourceIdQuery {
4211 pub(crate) fn to_query(&self) -> Query {
4212 let mut q = Query::new();
4213 self.include.push_query("include[]", &mut q);
4214 q
4215 }
4216}
4217
4218#[derive(Debug, Clone, Default)]
4220pub struct GetResourcesQuery {
4221 pub include: Option<Vec<String>>,
4224}
4225
4226impl GetResourcesQuery {
4227 pub(crate) fn to_query(&self) -> Query {
4228 let mut q = Query::new();
4229 self.include.push_query("include[]", &mut q);
4230 q
4231 }
4232}
4233
4234#[derive(Debug, Clone, Default)]
4236pub struct GetRoutinesQuery {
4237 pub domain_type: Option<String>,
4240}
4241
4242impl GetRoutinesQuery {
4243 pub(crate) fn to_query(&self) -> Query {
4244 let mut q = Query::new();
4245 self.domain_type.push_query("domain_type", &mut q);
4246 q
4247 }
4248}
4249
4250#[derive(Debug, Clone, Default)]
4252pub struct PatchRoutinesRoutineIdQuery {
4253 pub dry_run: Option<bool>,
4255}
4256
4257impl PatchRoutinesRoutineIdQuery {
4258 pub(crate) fn to_query(&self) -> Query {
4259 let mut q = Query::new();
4260 self.dry_run.push_query("dry_run", &mut q);
4261 q
4262 }
4263}
4264
4265#[derive(Debug, Clone, Default)]
4267pub struct GetRoutinesRoutineIdRunsQuery {
4268 pub include: Option<Vec<String>>,
4271 pub with_potential_domain_objects: Option<bool>,
4273}
4274
4275impl GetRoutinesRoutineIdRunsQuery {
4276 pub(crate) fn to_query(&self) -> Query {
4277 let mut q = Query::new();
4278 self.include.push_query("include[]", &mut q);
4279 self.with_potential_domain_objects.push_query("with_potential_domain_objects", &mut q);
4280 q
4281 }
4282}
4283
4284#[derive(Debug, Clone, Default)]
4286pub struct GetSamlLoginQuery {
4287 pub redirect: Option<String>,
4289}
4290
4291impl GetSamlLoginQuery {
4292 pub(crate) fn to_query(&self) -> Query {
4293 let mut q = Query::new();
4294 self.redirect.push_query("redirect", &mut q);
4295 q
4296 }
4297}
4298
4299#[derive(Debug, Clone, Default)]
4301pub struct GetSearchQuery {
4302 pub query: Option<String>,
4303 pub domain_types: Option<Vec<String>>,
4305}
4306
4307impl GetSearchQuery {
4308 pub(crate) fn to_query(&self) -> Query {
4309 let mut q = Query::new();
4310 self.query.push_query("query", &mut q);
4311 self.domain_types.push_query("domain_types[]", &mut q);
4312 q
4313 }
4314}
4315
4316#[derive(Debug, Clone, Default)]
4318pub struct DeleteSecuritylevelsIdQuery {
4319 pub dry_run: Option<bool>,
4321}
4322
4323impl DeleteSecuritylevelsIdQuery {
4324 pub(crate) fn to_query(&self) -> Query {
4325 let mut q = Query::new();
4326 self.dry_run.push_query("dry_run", &mut q);
4327 q
4328 }
4329}
4330
4331#[derive(Debug, Clone, Default)]
4333pub struct PatchSecuritylevelsIdQuery {
4334 pub forcereorder: Option<bool>,
4336}
4337
4338impl PatchSecuritylevelsIdQuery {
4339 pub(crate) fn to_query(&self) -> Query {
4340 let mut q = Query::new();
4341 self.forcereorder.push_query("forcereorder", &mut q);
4342 q
4343 }
4344}
4345
4346#[derive(Debug, Clone, Default)]
4348pub struct GetSongsSongIdQuery {
4349 pub include: Option<Vec<String>>,
4352}
4353
4354impl GetSongsSongIdQuery {
4355 pub(crate) fn to_query(&self) -> Query {
4356 let mut q = Query::new();
4357 self.include.push_query("include[]", &mut q);
4358 q
4359 }
4360}
4361
4362#[derive(Debug, Clone, Default)]
4364pub struct GetSongsQuery {
4365 pub song_category_ids: Option<Vec<i64>>,
4367 pub ids: Option<Vec<i64>>,
4369 pub practice: Option<bool>,
4371 pub key_of_arrangement: Option<String>,
4374 pub name: Option<String>,
4376 pub query: Option<String>,
4378 pub include: Option<Vec<String>>,
4381 pub limit: Option<i64>,
4383}
4384
4385impl GetSongsQuery {
4386 pub(crate) fn to_query(&self) -> Query {
4387 let mut q = Query::new();
4388 self.song_category_ids.push_query("song_category_ids[]", &mut q);
4389 self.ids.push_query("ids[]", &mut q);
4390 self.practice.push_query("practice", &mut q);
4391 self.key_of_arrangement.push_query("key_of_arrangement", &mut q);
4392 self.name.push_query("name", &mut q);
4393 self.query.push_query("query", &mut q);
4394 self.include.push_query("include[]", &mut q);
4395 self.limit.push_query("limit", &mut q);
4396 q
4397 }
4398}
4399
4400#[derive(Debug, Clone, Default)]
4402pub struct GetSyncExecutionsQuery {
4403 pub limit: Option<i64>,
4405 pub es_ids: Option<Vec<i64>>,
4407 pub job_ids: Option<Vec<i64>>,
4409 pub start_date: Option<chrono::NaiveDate>,
4411 pub end_date: Option<chrono::NaiveDate>,
4413 pub statuses: Option<Vec<String>>,
4416 pub is_dry_run: Option<bool>,
4418}
4419
4420impl GetSyncExecutionsQuery {
4421 pub(crate) fn to_query(&self) -> Query {
4422 let mut q = Query::new();
4423 self.limit.push_query("limit", &mut q);
4424 self.es_ids.push_query("es_ids[]", &mut q);
4425 self.job_ids.push_query("job_ids[]", &mut q);
4426 self.start_date.push_query("start_date", &mut q);
4427 self.end_date.push_query("end_date", &mut q);
4428 self.statuses.push_query("statuses[]", &mut q);
4429 self.is_dry_run.push_query("is_dry_run", &mut q);
4430 q
4431 }
4432}
4433
4434#[derive(Debug, Clone, Default)]
4436pub struct GetSyncJobconfigsQuery {
4437 pub external_system_ids: Option<Vec<i64>>,
4439}
4440
4441impl GetSyncJobconfigsQuery {
4442 pub(crate) fn to_query(&self) -> Query {
4443 let mut q = Query::new();
4444 self.external_system_ids.push_query("external_system_ids[]", &mut q);
4445 q
4446 }
4447}
4448
4449#[derive(Debug, Clone, Default)]
4451pub struct GetSyncLogsQuery {
4452 pub limit: Option<i64>,
4454 pub es_ids: Option<Vec<i64>>,
4456 pub job_ids: Option<Vec<i64>>,
4458 pub execution_ids: Option<Vec<String>>,
4460 pub start_date: Option<chrono::NaiveDate>,
4462 pub end_date: Option<chrono::NaiveDate>,
4464 pub types: Option<Vec<String>>,
4467 pub levels: Option<Vec<String>>,
4470 pub query: Option<String>,
4472 pub is_dry_run: Option<bool>,
4474}
4475
4476impl GetSyncLogsQuery {
4477 pub(crate) fn to_query(&self) -> Query {
4478 let mut q = Query::new();
4479 self.limit.push_query("limit", &mut q);
4480 self.es_ids.push_query("es_ids[]", &mut q);
4481 self.job_ids.push_query("job_ids[]", &mut q);
4482 self.execution_ids.push_query("execution_ids[]", &mut q);
4483 self.start_date.push_query("start_date", &mut q);
4484 self.end_date.push_query("end_date", &mut q);
4485 self.types.push_query("types[]", &mut q);
4486 self.levels.push_query("levels[]", &mut q);
4487 self.query.push_query("query", &mut q);
4488 self.is_dry_run.push_query("is_dry_run", &mut q);
4489 q
4490 }
4491}
4492
4493#[derive(Debug, Clone, Default)]
4495pub struct DeleteSyncAdaptersIdQuery {
4496 pub dry_run: Option<bool>,
4498}
4499
4500impl DeleteSyncAdaptersIdQuery {
4501 pub(crate) fn to_query(&self) -> Query {
4502 let mut q = Query::new();
4503 self.dry_run.push_query("dry_run", &mut q);
4504 q
4505 }
4506}
4507
4508#[derive(Debug, Clone, Default)]
4510pub struct GetSyncConflictsQuery {
4511 pub limit: Option<i64>,
4513 pub types: Option<Vec<String>>,
4516 pub domain_types: Option<Vec<String>>,
4519 pub source_ids: Option<Vec<i64>>,
4521}
4522
4523impl GetSyncConflictsQuery {
4524 pub(crate) fn to_query(&self) -> Query {
4525 let mut q = Query::new();
4526 self.limit.push_query("limit", &mut q);
4527 self.types.push_query("types[]", &mut q);
4528 self.domain_types.push_query("domain_types[]", &mut q);
4529 self.source_ids.push_query("source_ids[]", &mut q);
4530 q
4531 }
4532}
4533
4534#[derive(Debug, Clone, Default)]
4536pub struct GetSyncEntitymappingsQuery {
4537 pub limit: Option<i64>,
4539 pub domain_type: Option<Vec<String>>,
4542 pub domain_id: Option<Vec<String>>,
4544 pub source_entity_id: Option<Vec<String>>,
4546 pub source_id: Option<String>,
4548 pub scope: Option<String>,
4550}
4551
4552impl GetSyncEntitymappingsQuery {
4553 pub(crate) fn to_query(&self) -> Query {
4554 let mut q = Query::new();
4555 self.limit.push_query("limit", &mut q);
4556 self.domain_type.push_query("domain_type[]", &mut q);
4557 self.domain_id.push_query("domain_id[]", &mut q);
4558 self.source_entity_id.push_query("source_entity_id[]", &mut q);
4559 self.source_id.push_query("source_id", &mut q);
4560 self.scope.push_query("scope", &mut q);
4561 q
4562 }
4563}
4564
4565#[derive(Debug, Clone, Default)]
4567pub struct GetTranslationsQuery {
4568 pub updated_by_church: Option<bool>,
4570 pub needs_check: Option<bool>,
4572}
4573
4574impl GetTranslationsQuery {
4575 pub(crate) fn to_query(&self) -> Query {
4576 let mut q = Query::new();
4577 self.updated_by_church.push_query("updated_by_church", &mut q);
4578 self.needs_check.push_query("needs_check", &mut q);
4579 q
4580 }
4581}
4582
4583#[derive(Debug, Clone, Default)]
4585pub struct GetTranslationsKeysbytextQuery {
4586 pub query: Option<String>,
4588}
4589
4590impl GetTranslationsKeysbytextQuery {
4591 pub(crate) fn to_query(&self) -> Query {
4592 let mut q = Query::new();
4593 self.query.push_query("query", &mut q);
4594 q
4595 }
4596}
4597
4598#[derive(Debug, Clone, Default)]
4600pub struct GetWebsiteDataQuery {
4601 pub include: Option<Vec<String>>,
4604}
4605
4606impl GetWebsiteDataQuery {
4607 pub(crate) fn to_query(&self) -> Query {
4608 let mut q = Query::new();
4609 self.include.push_query("include[]", &mut q);
4610 q
4611 }
4612}
4613
4614#[derive(Debug, Clone, Default)]
4616pub struct GetWhoamiQuery {
4617 pub only_allow_authenticated: Option<bool>,
4619}
4620
4621impl GetWhoamiQuery {
4622 pub(crate) fn to_query(&self) -> Query {
4623 let mut q = Query::new();
4624 self.only_allow_authenticated.push_query("only_allow_authenticated", &mut q);
4625 q
4626 }
4627}
4628
4629#[derive(Debug, Clone, Default)]
4631pub struct GetWikiPagesQuery {
4632 pub limit: Option<i64>,
4634 pub query: Option<String>,
4636 pub wiki_category_ids: Option<Vec<i64>>,
4638 pub order_fields: Option<Vec<String>>,
4641 pub order_directions: Option<Vec<String>>,
4644 pub include: Option<Vec<String>>,
4647 pub preview_length: Option<i64>,
4649}
4650
4651impl GetWikiPagesQuery {
4652 pub(crate) fn to_query(&self) -> Query {
4653 let mut q = Query::new();
4654 self.limit.push_query("limit", &mut q);
4655 self.query.push_query("query", &mut q);
4656 self.wiki_category_ids.push_query("wiki_category_ids[]", &mut q);
4657 self.order_fields.push_query("order_fields[]", &mut q);
4658 self.order_directions.push_query("order_directions[]", &mut q);
4659 self.include.push_query("include[]", &mut q);
4660 self.preview_length.push_query("preview_length", &mut q);
4661 q
4662 }
4663}
4664
4665#[derive(Debug, Clone, Default)]
4667pub struct GetWikiSearchQuery {
4668 pub query: Option<String>,
4670 pub wiki_category_ids: Option<Vec<i64>>,
4672}
4673
4674impl GetWikiSearchQuery {
4675 pub(crate) fn to_query(&self) -> Query {
4676 let mut q = Query::new();
4677 self.query.push_query("query", &mut q);
4678 self.wiki_category_ids.push_query("wiki_category_ids[]", &mut q);
4679 q
4680 }
4681}
4682
4683#[derive(Debug, Clone, Default)]
4685pub struct GetWikiCategoriesIdPagesIdentifierQuery {
4686 pub version: Option<i64>,
4688}
4689
4690impl GetWikiCategoriesIdPagesIdentifierQuery {
4691 pub(crate) fn to_query(&self) -> Query {
4692 let mut q = Query::new();
4693 self.version.push_query("version", &mut q);
4694 q
4695 }
4696}