//! Resource handles returned by the accessors of [`Client`](crate::Client), e.g.
//! `client.persons()`, with one method per endpoint.
//!
//! Generated by codegen/generate.py from the OpenAPI spec of ChurchTools 3.138.1 (build 32938). Do not edit. The spec is licensed under CC BY 4.0 (<https://creativecommons.org/licenses/by/4.0/>); see NOTICE.
#![allow(clippy::all, deprecated, unused_mut)]
use std::fmt::Display;
use super::models;
use super::queries::*;
use crate::client::{Client, Items, Method, Query, Upload, encode_path_segment as seg};
use crate::error::Result;
impl Client {
/// Endpoints under `/actions` (1 operations), see [`ActionsResource`].
pub fn actions(&self) -> ActionsResource<'_> {
ActionsResource { client: self }
}
/// Endpoints under `/addresses` (5 operations), see [`AddressesResource`].
pub fn addresses(&self) -> AddressesResource<'_> {
AddressesResource { client: self }
}
/// Endpoints under `/agenda_templates` (11 operations), see [`AgendaTemplatesResource`].
pub fn agenda_templates(&self) -> AgendaTemplatesResource<'_> {
AgendaTemplatesResource { client: self }
}
/// Endpoints under `/agendas` (1 operations), see [`AgendasResource`].
pub fn agendas(&self) -> AgendasResource<'_> {
AgendasResource { client: self }
}
/// Endpoints under `/bookings` (9 operations), see [`BookingsResource`].
pub fn bookings(&self) -> BookingsResource<'_> {
BookingsResource { client: self }
}
/// Endpoints under `/bulk_jobs` (2 operations), see [`BulkJobsResource`].
pub fn bulk_jobs(&self) -> BulkJobsResource<'_> {
BulkJobsResource { client: self }
}
/// Endpoints under `/bulk_letters` (6 operations), see [`BulkLettersResource`].
pub fn bulk_letters(&self) -> BulkLettersResource<'_> {
BulkLettersResource { client: self }
}
/// Endpoints under `/calendars` (28 operations), see [`CalendarsResource`].
pub fn calendars(&self) -> CalendarsResource<'_> {
CalendarsResource { client: self }
}
/// Endpoints under `/campuses` (5 operations), see [`CampusesResource`].
pub fn campuses(&self) -> CampusesResource<'_> {
CampusesResource { client: self }
}
/// Endpoints under `/captcha` (2 operations), see [`CaptchaResource`].
pub fn captcha(&self) -> CaptchaResource<'_> {
CaptchaResource { client: self }
}
/// Endpoints under `/chat` (4 operations), see [`ChatResource`].
pub fn chat(&self) -> ChatResource<'_> {
ChatResource { client: self }
}
/// Endpoints under `/checkin` (2 operations), see [`CheckinResource`].
pub fn checkin(&self) -> CheckinResource<'_> {
CheckinResource { client: self }
}
/// Endpoints under `/church_query` (2 operations), see [`ChurchQueryResource`].
pub fn church_query(&self) -> ChurchQueryResource<'_> {
ChurchQueryResource { client: self }
}
/// Endpoints under `/config` (2 operations), see [`ConfigResource`].
pub fn config(&self) -> ConfigResource<'_> {
ConfigResource { client: self }
}
/// Endpoints under `/contact_labels` (5 operations), see [`ContactLabelsResource`].
pub fn contact_labels(&self) -> ContactLabelsResource<'_> {
ContactLabelsResource { client: self }
}
/// Endpoints under `/csrf_token` (1 operations), see [`CsrfTokenResource`].
pub fn csrf_token(&self) -> CsrfTokenResource<'_> {
CsrfTokenResource { client: self }
}
/// Endpoints under `/db_field_types` (1 operations), see [`DbFieldTypesResource`].
pub fn db_field_types(&self) -> DbFieldTypesResource<'_> {
DbFieldTypesResource { client: self }
}
/// Endpoints under `/db_fields` (10 operations), see [`DbFieldsResource`].
pub fn db_fields(&self) -> DbFieldsResource<'_> {
DbFieldsResource { client: self }
}
/// Endpoints under `/departments` (1 operations), see [`DepartmentsResource`].
pub fn departments(&self) -> DepartmentsResource<'_> {
DepartmentsResource { client: self }
}
/// Endpoints under `/domain_objects` (2 operations), see [`DomainObjectsResource`].
pub fn domain_objects(&self) -> DomainObjectsResource<'_> {
DomainObjectsResource { client: self }
}
/// Endpoints under `/dynamic_groups` (8 operations), see [`DynamicGroupsResource`].
pub fn dynamic_groups(&self) -> DynamicGroupsResource<'_> {
DynamicGroupsResource { client: self }
}
/// Endpoints under `/emails` (2 operations), see [`EmailsResource`].
pub fn emails(&self) -> EmailsResource<'_> {
EmailsResource { client: self }
}
/// Endpoints under `/evangelische_termine` (3 operations), see [`EvangelischeTermineResource`].
pub fn evangelische_termine(&self) -> EvangelischeTermineResource<'_> {
EvangelischeTermineResource { client: self }
}
/// Endpoints under `/event` (1 operations), see [`EventResource`].
pub fn event(&self) -> EventResource<'_> {
EventResource { client: self }
}
/// Endpoints under `/event_templates` (1 operations), see [`EventTemplatesResource`].
pub fn event_templates(&self) -> EventTemplatesResource<'_> {
EventTemplatesResource { client: self }
}
/// Endpoints under `/events` (39 operations), see [`EventsResource`].
pub fn events(&self) -> EventsResource<'_> {
EventsResource { client: self }
}
/// Endpoints under `/external_logins` (24 operations), see [`ExternalLoginsResource`].
pub fn external_logins(&self) -> ExternalLoginsResource<'_> {
ExternalLoginsResource { client: self }
}
/// Endpoints under `/external_posts` (2 operations), see [`ExternalPostsResource`].
pub fn external_posts(&self) -> ExternalPostsResource<'_> {
ExternalPostsResource { client: self }
}
/// Endpoints under `/facts` (5 operations), see [`FactsResource`].
pub fn facts(&self) -> FactsResource<'_> {
FactsResource { client: self }
}
/// Endpoints under `/feature_usage` (1 operations), see [`FeatureUsageResource`].
pub fn feature_usage(&self) -> FeatureUsageResource<'_> {
FeatureUsageResource { client: self }
}
/// Endpoints under `/fields` (1 operations), see [`FieldsResource`].
pub fn fields(&self) -> FieldsResource<'_> {
FieldsResource { client: self }
}
/// Endpoints under `/files` (10 operations), see [`FilesResource`].
pub fn files(&self) -> FilesResource<'_> {
FilesResource { client: self }
}
/// Endpoints under `/finance` (134 operations), see [`FinanceResource`].
pub fn finance(&self) -> FinanceResource<'_> {
FinanceResource { client: self }
}
/// Endpoints under `/followups` (9 operations), see [`FollowupsResource`].
pub fn followups(&self) -> FollowupsResource<'_> {
FollowupsResource { client: self }
}
/// Endpoints under `/further_links` (5 operations), see [`FurtherLinksResource`].
pub fn further_links(&self) -> FurtherLinksResource<'_> {
FurtherLinksResource { client: self }
}
/// Endpoints under `/group` (31 operations), see [`GroupResource`].
pub fn group(&self) -> GroupResource<'_> {
GroupResource { client: self }
}
/// Endpoints under `/group_homepages` (2 operations), see [`GroupHomepagesResource`].
pub fn group_homepages(&self) -> GroupHomepagesResource<'_> {
GroupHomepagesResource { client: self }
}
/// Endpoints under `/groups` (78 operations), see [`GroupsResource`].
pub fn groups(&self) -> GroupsResource<'_> {
GroupsResource { client: self }
}
/// Endpoints under `/history` (1 operations), see [`HistoryResource`].
pub fn history(&self) -> HistoryResource<'_> {
HistoryResource { client: self }
}
/// Endpoints under `/html_templates` (9 operations), see [`HtmlTemplatesResource`].
pub fn html_templates(&self) -> HtmlTemplatesResource<'_> {
HtmlTemplatesResource { client: self }
}
/// Endpoints under `/images` (4 operations), see [`ImagesResource`].
pub fn images(&self) -> ImagesResource<'_> {
ImagesResource { client: self }
}
/// Endpoints under `/info` (1 operations), see [`InfoResource`].
pub fn info(&self) -> InfoResource<'_> {
InfoResource { client: self }
}
/// Endpoints under `/installation_sync` (1 operations), see [`InstallationSyncResource`].
pub fn installation_sync(&self) -> InstallationSyncResource<'_> {
InstallationSyncResource { client: self }
}
/// Endpoints under `/job_log` (1 operations), see [`JobLogResource`].
pub fn job_log(&self) -> JobLogResource<'_> {
JobLogResource { client: self }
}
/// Endpoints under `/jobs` (3 operations), see [`JobsResource`].
pub fn jobs(&self) -> JobsResource<'_> {
JobsResource { client: self }
}
/// Endpoints under `/labels` (2 operations), see [`LabelsResource`].
pub fn labels(&self) -> LabelsResource<'_> {
LabelsResource { client: self }
}
/// Endpoints under `/languages` (1 operations), see [`LanguagesResource`].
pub fn languages(&self) -> LanguagesResource<'_> {
LanguagesResource { client: self }
}
/// Endpoints under `/license` (1 operations), see [`LicenseResource`].
pub fn license(&self) -> LicenseResource<'_> {
LicenseResource { client: self }
}
/// Endpoints under `/login` (5 operations), see [`LoginResource`].
pub fn login(&self) -> LoginResource<'_> {
LoginResource { client: self }
}
/// Endpoints under `/logout` (1 operations), see [`LogoutResource`].
pub fn logout(&self) -> LogoutResource<'_> {
LogoutResource { client: self }
}
/// Endpoints under `/logs` (3 operations), see [`LogsResource`].
pub fn logs(&self) -> LogsResource<'_> {
LogsResource { client: self }
}
/// Endpoints under `/markdown` (2 operations), see [`MarkdownResource`].
pub fn markdown(&self) -> MarkdownResource<'_> {
MarkdownResource { client: self }
}
/// Endpoints under `/master_data` (1 operations), see [`MasterDataResource`].
pub fn master_data(&self) -> MasterDataResource<'_> {
MasterDataResource { client: self }
}
/// Endpoints under `/meeting_requests` (1 operations), see [`MeetingRequestsResource`].
pub fn meeting_requests(&self) -> MeetingRequestsResource<'_> {
MeetingRequestsResource { client: self }
}
/// Endpoints under `/menu` (1 operations), see [`MenuResource`].
pub fn menu(&self) -> MenuResource<'_> {
MenuResource { client: self }
}
/// Endpoints under `/news_letter_integrations` (1 operations), see [`NewsLetterIntegrationsResource`].
pub fn news_letter_integrations(&self) -> NewsLetterIntegrationsResource<'_> {
NewsLetterIntegrationsResource { client: self }
}
/// Endpoints under `/notes` (5 operations), see [`NotesResource`].
pub fn notes(&self) -> NotesResource<'_> {
NotesResource { client: self }
}
/// Endpoints under `/notifications` (1 operations), see [`NotificationsResource`].
pub fn notifications(&self) -> NotificationsResource<'_> {
NotificationsResource { client: self }
}
/// Endpoints under `/nps` (1 operations), see [`NpsResource`].
pub fn nps(&self) -> NpsResource<'_> {
NpsResource { client: self }
}
/// Endpoints under `/oauth_clients` (4 operations), see [`OauthClientsResource`].
pub fn oauth_clients(&self) -> OauthClientsResource<'_> {
OauthClientsResource { client: self }
}
/// Endpoints under `/permissions` (21 operations), see [`PermissionsResource`].
pub fn permissions(&self) -> PermissionsResource<'_> {
PermissionsResource { client: self }
}
/// Endpoints under `/person` (21 operations), see [`PersonResource`].
pub fn person(&self) -> PersonResource<'_> {
PersonResource { client: self }
}
/// Endpoints under `/persons` (72 operations), see [`PersonsResource`].
pub fn persons(&self) -> PersonsResource<'_> {
PersonsResource { client: self }
}
/// Endpoints under `/placeholders` (2 operations), see [`PlaceholdersResource`].
pub fn placeholders(&self) -> PlaceholdersResource<'_> {
PlaceholdersResource { client: self }
}
/// Endpoints under `/poll_for_news` (1 operations), see [`PollForNewsResource`].
pub fn poll_for_news(&self) -> PollForNewsResource<'_> {
PollForNewsResource { client: self }
}
/// Endpoints under `/post` (8 operations), see [`PostResource`].
pub fn post(&self) -> PostResource<'_> {
PostResource { client: self }
}
/// Endpoints under `/posts` (16 operations), see [`PostsResource`].
pub fn posts(&self) -> PostsResource<'_> {
PostsResource { client: self }
}
/// Endpoints under `/pr` (1 operations), see [`PrResource`].
pub fn pr(&self) -> PrResource<'_> {
PrResource { client: self }
}
/// Endpoints under `/printers` (1 operations), see [`PrintersResource`].
pub fn printers(&self) -> PrintersResource<'_> {
PrintersResource { client: self }
}
/// Endpoints under `/probes` (1 operations), see [`ProbesResource`].
pub fn probes(&self) -> ProbesResource<'_> {
ProbesResource { client: self }
}
/// Endpoints under `/profiles` (5 operations), see [`ProfilesResource`].
pub fn profiles(&self) -> ProfilesResource<'_> {
ProfilesResource { client: self }
}
/// Endpoints under `/public_groups` (11 operations), see [`PublicGroupsResource`].
pub fn public_groups(&self) -> PublicGroupsResource<'_> {
PublicGroupsResource { client: self }
}
/// Endpoints under `/queues` (2 operations), see [`QueuesResource`].
pub fn queues(&self) -> QueuesResource<'_> {
QueuesResource { client: self }
}
/// Endpoints under `/registration_config` (2 operations), see [`RegistrationConfigResource`].
pub fn registration_config(&self) -> RegistrationConfigResource<'_> {
RegistrationConfigResource { client: self }
}
/// Endpoints under `/registrations` (5 operations), see [`RegistrationsResource`].
pub fn registrations(&self) -> RegistrationsResource<'_> {
RegistrationsResource { client: self }
}
/// Endpoints under `/repeat_calculation` (5 operations), see [`RepeatCalculationResource`].
pub fn repeat_calculation(&self) -> RepeatCalculationResource<'_> {
RepeatCalculationResource { client: self }
}
/// Endpoints under `/reset_password` (1 operations), see [`ResetPasswordResource`].
pub fn reset_password(&self) -> ResetPasswordResource<'_> {
ResetPasswordResource { client: self }
}
/// Endpoints under `/resource` (1 operations), see [`ResourceResource`].
pub fn resource(&self) -> ResourceResource<'_> {
ResourceResource { client: self }
}
/// Endpoints under `/resource_types` (5 operations), see [`ResourceTypesResource`].
pub fn resource_types(&self) -> ResourceTypesResource<'_> {
ResourceTypesResource { client: self }
}
/// Endpoints under `/resources` (6 operations), see [`ResourcesResource`].
pub fn resources(&self) -> ResourcesResource<'_> {
ResourcesResource { client: self }
}
/// Endpoints under `/routines` (10 operations), see [`RoutinesResource`].
pub fn routines(&self) -> RoutinesResource<'_> {
RoutinesResource { client: self }
}
/// Endpoints under `/saml` (3 operations), see [`SamlResource`].
pub fn saml(&self) -> SamlResource<'_> {
SamlResource { client: self }
}
/// Endpoints under `/search` (1 operations), see [`SearchResource`].
pub fn search(&self) -> SearchResource<'_> {
SearchResource { client: self }
}
/// Endpoints under `/security_levels` (5 operations), see [`SecurityLevelsResource`].
pub fn security_levels(&self) -> SecurityLevelsResource<'_> {
SecurityLevelsResource { client: self }
}
/// Endpoints under `/service_groups` (5 operations), see [`ServiceGroupsResource`].
pub fn service_groups(&self) -> ServiceGroupsResource<'_> {
ServiceGroupsResource { client: self }
}
/// Endpoints under `/services` (5 operations), see [`ServicesResource`].
pub fn services(&self) -> ServicesResource<'_> {
ServicesResource { client: self }
}
/// Endpoints under `/simulate` (2 operations), see [`SimulateResource`].
pub fn simulate(&self) -> SimulateResource<'_> {
SimulateResource { client: self }
}
/// Endpoints under `/song` (10 operations), see [`SongResource`].
pub fn song(&self) -> SongResource<'_> {
SongResource { client: self }
}
/// Endpoints under `/songs` (12 operations), see [`SongsResource`].
pub fn songs(&self) -> SongsResource<'_> {
SongsResource { client: self }
}
/// Endpoints under `/sso_logins` (1 operations), see [`SsoLoginsResource`].
pub fn sso_logins(&self) -> SsoLoginsResource<'_> {
SsoLoginsResource { client: self }
}
/// Endpoints under `/start_page` (1 operations), see [`StartPageResource`].
pub fn start_page(&self) -> StartPageResource<'_> {
StartPageResource { client: self }
}
/// Endpoints under `/statuses` (6 operations), see [`StatusesResource`].
pub fn statuses(&self) -> StatusesResource<'_> {
StatusesResource { client: self }
}
/// Endpoints under `/subscriptions` (5 operations), see [`SubscriptionsResource`].
pub fn subscriptions(&self) -> SubscriptionsResource<'_> {
SubscriptionsResource { client: self }
}
/// Endpoints under `/sync` (55 operations), see [`SyncResource`].
pub fn sync(&self) -> SyncResource<'_> {
SyncResource { client: self }
}
/// Endpoints under `/tags` (9 operations), see [`TagsResource`].
pub fn tags(&self) -> TagsResource<'_> {
TagsResource { client: self }
}
/// Endpoints under `/translations` (5 operations), see [`TranslationsResource`].
pub fn translations(&self) -> TranslationsResource<'_> {
TranslationsResource { client: self }
}
/// Endpoints under `/two_factor` (1 operations), see [`TwoFactorResource`].
pub fn two_factor(&self) -> TwoFactorResource<'_> {
TwoFactorResource { client: self }
}
/// Endpoints under `/website` (4 operations), see [`WebsiteResource`].
pub fn website(&self) -> WebsiteResource<'_> {
WebsiteResource { client: self }
}
/// Endpoints under `/whoami` (1 operations), see [`WhoamiResource`].
pub fn whoami(&self) -> WhoamiResource<'_> {
WhoamiResource { client: self }
}
/// Endpoints under `/widgets` (2 operations), see [`WidgetsResource`].
pub fn widgets(&self) -> WidgetsResource<'_> {
WidgetsResource { client: self }
}
/// Endpoints under `/wiki` (13 operations), see [`WikiResource`].
pub fn wiki(&self) -> WikiResource<'_> {
WikiResource { client: self }
}
}
/// `client.actions()`
#[derive(Clone, Copy)]
pub struct ActionsResource<'a> {
client: &'a Client,
}
impl<'a> ActionsResource<'a> {
/// Get filtered actions
///
/// `POST /actions`
///
/// Returns all available actions filtered by one or more domain types. Actions represent executable operations on domain objects (e.g. adding a member to a group, changing a member status). The optional filter object can be used to further narrow down the returned actions based on domain-specific criteria.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostActionsBody {
/// domain_type: vec!["group_membership".into()],
/// ..Default::default()
/// };
/// for action in client.actions().filter(&body)? {
/// println!("{}", action.domain_type);
/// }
/// # Ok(())
/// # }
/// ```
pub fn filter(&self, body: &models::PostActionsBody) -> Result<Vec<models::Action>> {
let path = "/actions".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.addresses()`
#[derive(Clone, Copy)]
pub struct AddressesResource<'a> {
client: &'a Client,
}
impl<'a> AddressesResource<'a> {
/// Create an address for a domain object
///
/// `POST /addresses/{domainType}/{domainIdentifier}`
///
/// Creates another stored meeting-place address for the group. Only domainType=group is registered. Requires permission to edit the group’s meeting-place field (treffpunkt). Ownership and address ID are supplied in the path. Coordinates are accepted as numbers or decimal strings and returned as strings or null. The request does not geocode a postal address automatically.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-addresses-domainType-domainIdentifier");
/// let body = models::GroupAddressCreate {
/// name: Some(Some("Retreat Center".into())),
/// ..Default::default()
/// };
/// let result = client.addresses().create("group", "42", &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, domain_type: impl Display, domain_identifier: impl Display, body: &models::GroupAddressCreate) -> Result<models::StoredAddress> {
let path = format!("/addresses/{}/{}", seg(domain_type), seg(domain_identifier));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete an address
///
/// `DELETE /addresses/{domainType}/{domainIdentifier}/{addressId}`
///
/// Deletes the stored address identified by addressId. Only domainType=group is registered. Requires permission to edit the meeting-place field (treffpunkt) of the group in the path. The group itself remains. This operation has no dry-run mode; an unknown address ID returns 404.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.addresses().delete("group", "42", 7)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, domain_type: impl Display, domain_identifier: impl Display, address_id: impl Display) -> Result<()> {
let path = format!("/addresses/{}/{}/{}", seg(domain_type), seg(domain_identifier), seg(address_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get addresses by domain object
///
/// `GET /addresses/{domainType}/{domainIdentifier}`
///
/// Returns stored meeting-place addresses for the group in the path. Only domainType=group is currently registered for this endpoint. Requires permission to view the group. The list is unpaginated, with no guaranteed order; meta.count is the number of addresses returned. An existing group without addresses returns an empty list.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-addresses-domainType-domainIdentifier");
/// for address in client.addresses().get("group", "42")? {
/// println!("{:?}", address.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn get(&self, domain_type: impl Display, domain_identifier: impl Display) -> Result<Vec<models::StoredAddress>> {
let path = format!("/addresses/{}/{}", seg(domain_type), seg(domain_identifier));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Search for addresses
///
/// `GET /addresses/search`
///
/// Searches for addresses across persons and a global geocoding service (e.g. Nominatim/Photon). Returns matching results from both sources. The query must be at least 2 characters long.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-addresses-search");
/// let query = GetAddressesSearchQuery {
/// query: Some("Musterstraße".into()),
/// ..Default::default()
/// };
/// for search in client.addresses().list_search(&query)? {
/// println!("{:?}", search);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_search(&self, query: &GetAddressesSearchQuery) -> Result<Vec<models::AddressSearchResult>> {
let path = "/addresses/search".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update an address
///
/// `PUT /addresses/{domainType}/{domainIdentifier}/{addressId}`
///
/// Replaces a stored meeting-place address. Omitted body fields are cleared; send all values to retain. Only domainType=group is registered. Requires permission to edit the group’s meeting-place field (treffpunkt). Ownership and address ID are supplied in the path. Coordinates are accepted as numbers or decimal strings and returned as strings or null. The request does not geocode a postal address automatically.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-addresses-domainType-domainIdentifier-addressId");
/// let body = models::GroupAddressUpdate {
/// name: Some(Some("Retreat Center".into())),
/// ..Default::default()
/// };
/// let result = client.addresses().update("group", "42", 7, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, domain_type: impl Display, domain_identifier: impl Display, address_id: impl Display, body: &models::GroupAddressUpdate) -> Result<models::StoredAddress> {
let path = format!("/addresses/{}/{}/{}", seg(domain_type), seg(domain_identifier), seg(address_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.agenda_templates()`
#[derive(Clone, Copy)]
pub struct AgendaTemplatesResource<'a> {
client: &'a Client,
}
impl<'a> AgendaTemplatesResource<'a> {
pub fn items(&self) -> AgendaTemplatesItemsResource<'a> {
AgendaTemplatesItemsResource { client: self.client }
}
/// Create agenda template
///
/// `POST /agendatemplates`
///
/// Creates a reusable agenda template and returns HTTP `200` with its complete representation. The caller must be a super administrator or have "edit agenda templates" for the supplied calendar. Items are optional and new templates start unlocked. Template responses use the Agenda schema: name is the stored template name, item start values are `null` and `startTimes` objects are empty.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-agendatemplates");
/// let body = models::AgendaTemplateCreate {
/// calendar_id: 1,
/// name: "Sunday Service Template".into(),
/// ..Default::default()
/// };
/// let result = client.agenda_templates().create(&body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::AgendaTemplateCreate) -> Result<models::Agenda> {
let path = "/agendatemplates".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete agenda template
///
/// `DELETE /agendatemplates/{agendaId}`
///
/// Deletes an unlocked agenda template. Previously copied event agendas retain their independent content. Requires a super administrator or "edit agenda templates" for the template calendar. Passing `dryRun`=`true` still deletes the template; this endpoint does not offer a deletion preview.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.agenda_templates().delete(35)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, agenda_id: impl Display) -> Result<()> {
self.delete_with(agenda_id, &Default::default())
}
/// Delete agenda template
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /agendatemplates/{agendaId}`
///
/// Deletes an unlocked agenda template. Previously copied event agendas retain their independent content. Requires a super administrator or "edit agenda templates" for the template calendar. Passing `dryRun`=`true` still deletes the template; this endpoint does not offer a deletion preview.
pub fn delete_with(&self, agenda_id: impl Display, query: &DeleteAgendatemplatesAgendaIdQuery) -> Result<()> {
let path = format!("/agendatemplates/{}", seg(agenda_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Export agenda template
///
/// `POST /agendatemplates/{agendaId}/export`
///
/// Generates a presenter import archive from an agenda template. Requires a super administrator or "view agenda", "edit agenda" or "edit agenda templates" for its calendar. Locked and unlocked agendas can be exported. Exports of unlocked agendas have a DRAFT label in the generated export name.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = PostAgendatemplatesAgendaIdExportQuery {
/// format: Some("SONG_BEAMER".into()),
/// ..Default::default()
/// };
/// let body = models::AgendaExportCreate {
/// append_arrangement: true,
/// export_songs: true,
/// with_category: false,
/// ..Default::default()
/// };
/// let agenda_template = client.agenda_templates().export(35, &query, &body)?;
/// println!("{}", agenda_template.url);
/// # Ok(())
/// # }
/// ```
pub fn export(&self, agenda_id: impl Display, query: &PostAgendatemplatesAgendaIdExportQuery, body: &models::AgendaExportCreate) -> Result<models::AgendaExport> {
let path = format!("/agendatemplates/{}/export", seg(agenda_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get agenda template
///
/// `GET /agendatemplates/{agendaId}`
///
/// Returns one agenda template with its complete ordered item list. An ID belonging to an event agenda is not a template and returns `404`. Visibility requires a super administrator or one of "view agenda", "edit agenda" or "edit agenda templates" for the template calendar. Template responses use the Agenda schema: name is the stored template name, item start values are `null` and `startTimes` objects are empty.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-agendatemplates-agendaId");
/// let agenda_template = client.agenda_templates().get(35)?;
/// println!("{:?}", agenda_template.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, agenda_id: impl Display) -> Result<models::Agenda> {
let path = format!("/agendatemplates/{}", seg(agenda_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all agenda templates
///
/// `GET /agendatemplates`
///
/// Returns every agenda template visible to the caller, including its items. Visibility requires a super administrator or one of "view agenda", "edit agenda" or "edit agenda templates" for the template calendar. Template responses use the Agenda schema: name is the stored template name, item start values are `null` and `startTimes` objects are empty.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-agendatemplates");
/// for agenda_template in client.agenda_templates().list()? {
/// println!("{:?}", agenda_template.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Agenda>> {
let path = "/agendatemplates".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update agenda template
///
/// `PUT /agendatemplates/{agendaId}`
///
/// Updates the template metadata and, when supplied, replaces its complete item list. Existing item IDs may be supplied once each to retain those items. The template must be unlocked. Requires a super administrator or "edit agenda templates" for the template's existing calendar.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-agendatemplates-agendaId");
/// let body = models::AgendaTemplateUpdate {
/// calendar_id: 1,
/// name: "Sunday Service Template".into(),
/// ..Default::default()
/// };
/// let result = client.agenda_templates().update(35, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, agenda_id: impl Display, body: &models::AgendaTemplateUpdate) -> Result<models::Agenda> {
let path = format!("/agendatemplates/{}", seg(agenda_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.agenda_templates().items()`
#[derive(Clone, Copy)]
pub struct AgendaTemplatesItemsResource<'a> {
client: &'a Client,
}
impl<'a> AgendaTemplatesItemsResource<'a> {
pub fn service_groups(&self) -> AgendaTemplatesItemsServiceGroupsResource<'a> {
AgendaTemplatesItemsServiceGroupsResource { client: self.client }
}
/// Create agenda template item
///
/// `POST /agendatemplates/{agendaId}/items`
///
/// Adds a header, text or song item to an existing agenda template. Without `before_id` or `after_id`, the new item is appended. Use at most one of `before_id` and `after_id`, referring to an item in the same template. Relative positioning can adjust `eventStartPosition`. Requires a super administrator or "edit agenda templates" for the template calendar.
///
/// Use [`Self::create_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-agendatemplates-agendaId-items");
/// let body = serde_json::json!({
/// "type": "header"
/// });
/// let result = client.agenda_templates().items().create(35, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, agenda_id: impl Display, body: &serde_json::Value) -> Result<serde_json::Value> {
self.create_with(agenda_id, &Default::default(), body)
}
/// Create agenda template item
///
/// Like [`Self::create`], with query parameters.
///
/// `POST /agendatemplates/{agendaId}/items`
///
/// Adds a header, text or song item to an existing agenda template. Without `before_id` or `after_id`, the new item is appended. Use at most one of `before_id` and `after_id`, referring to an item in the same template. Relative positioning can adjust `eventStartPosition`. Requires a super administrator or "edit agenda templates" for the template calendar.
pub fn create_with(&self, agenda_id: impl Display, query: &PostAgendatemplatesAgendaIdItemsQuery, body: &serde_json::Value) -> Result<serde_json::Value> {
let path = format!("/agendatemplates/{}/items", seg(agenda_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete agenda template item
///
/// `DELETE /agendatemplates/{agendaId}/items/{itemId}`
///
/// Removes one item from the template, including its service-group notes. Other items remain. Repeating the deletion returns `404` because the item no longer exists. Requires a super administrator or "edit agenda templates" for the template calendar.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.agenda_templates().items().delete(35, 123)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, agenda_id: impl Display, item_id: impl Display) -> Result<()> {
let path = format!("/agendatemplates/{}/items/{}", seg(agenda_id), seg(item_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Update agenda template item
///
/// `PUT /agendatemplates/{agendaId}/items/{itemId}`
///
/// Updates one item in an agenda template. The item must belong to this template. Without `before_id` or `after_id` its position is retained. Moving an item still requires type and, for a song, `arrangementId`; this is not a position-only patch. Requires a super administrator or "edit agenda templates" for the template calendar.
///
/// Use [`Self::update_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-agendatemplates-agendaId-items-itemId");
/// let body = serde_json::json!({
/// "type": "header"
/// });
/// let result = client.agenda_templates().items().update(35, 123, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, agenda_id: impl Display, item_id: impl Display, body: &serde_json::Value) -> Result<serde_json::Value> {
self.update_with(agenda_id, item_id, &Default::default(), body)
}
/// Update agenda template item
///
/// Like [`Self::update`], with query parameters.
///
/// `PUT /agendatemplates/{agendaId}/items/{itemId}`
///
/// Updates one item in an agenda template. The item must belong to this template. Without `before_id` or `after_id` its position is retained. Moving an item still requires type and, for a song, `arrangementId`; this is not a position-only patch. Requires a super administrator or "edit agenda templates" for the template calendar.
pub fn update_with(&self, agenda_id: impl Display, item_id: impl Display, query: &PutAgendatemplatesAgendaIdItemsItemIdQuery, body: &serde_json::Value) -> Result<serde_json::Value> {
let path = format!("/agendatemplates/{}/items/{}", seg(agenda_id), seg(item_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.agenda_templates().items().service_groups()`
#[derive(Clone, Copy)]
pub struct AgendaTemplatesItemsServiceGroupsResource<'a> {
client: &'a Client,
}
impl<'a> AgendaTemplatesItemsServiceGroupsResource<'a> {
/// Delete service group note from agenda template item
///
/// `DELETE /agendatemplates/{agendaId}/items/{itemId}/servicegroups/{serviceGroupId}`
///
/// Removes the note for one service group on a template item. An already absent note still returns `204`; an absent item returns `404`. Notes for other service groups and the remaining item content are retained. Template reads return service-group notes without filtering by service-group visibility. Requires a super administrator or "edit agenda templates" for the template calendar.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.agenda_templates().items().service_groups().delete(35, 123, 13)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, agenda_id: impl Display, item_id: impl Display, service_group_id: impl Display) -> Result<()> {
let path = format!("/agendatemplates/{}/items/{}/servicegroups/{}", seg(agenda_id), seg(item_id), seg(service_group_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Add or update service group note for agenda template item
///
/// `PUT /agendatemplates/{agendaId}/items/{itemId}/servicegroups/{serviceGroupId}`
///
/// Creates or replaces the note for one service group on a template item. Notes for other service groups and the remaining item content are retained. Template reads return service-group notes without filtering by service-group visibility. Requires a super administrator or "edit agenda templates" for the template calendar.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AgendaServiceGroupNoteUpdate {
/// note: Some(Some("Remember to bring the sheet music".into())),
/// ..Default::default()
/// };
/// client.agenda_templates().items().service_groups().update(35, 123, 13, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, agenda_id: impl Display, item_id: impl Display, service_group_id: impl Display, body: &models::AgendaServiceGroupNoteUpdate) -> Result<()> {
let path = format!("/agendatemplates/{}/items/{}/servicegroups/{}", seg(agenda_id), seg(item_id), seg(service_group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.agendas()`
#[derive(Clone, Copy)]
pub struct AgendasResource<'a> {
client: &'a Client,
}
impl<'a> AgendasResource<'a> {
/// Send agenda email to recipients
///
/// `POST /agendas/send`
///
/// Deprecated compatibility endpoint for `POST /events/send`. Recipients are filtered to selected participants in visible service groups or other selected people the sender may view and the response reports the effective scope. `sendCopyToMe` can add the sender. Events do not have to share an agenda. Agenda links are included for events whose agenda the sender may view.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AgendaMailCreate {
/// body: "<p>Please review the updated agenda for Sunday.</p>".into(),
/// event_ids: vec![31, 32],
/// recipients: vec![40, 41],
/// subject: "Updated Sunday agenda".into(),
/// ..Default::default()
/// };
/// let agenda = client.agendas().send(&body)?;
/// println!("{:?}", agenda);
/// # Ok(())
/// # }
/// ```
#[deprecated = "POST /agendas/send is deprecated in the ChurchTools API."]
pub fn send(&self, body: &models::AgendaMailCreate) -> Result<models::EventMailSendResult> {
let path = "/agendas/send".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.bookings()`
#[derive(Clone, Copy)]
pub struct BookingsResource<'a> {
client: &'a Client,
}
impl<'a> BookingsResource<'a> {
/// Answer a booking request
///
/// `PUT /bookings/{bookingId}/{answer}`
///
/// Changes the status of the entire booking: `approve` sets approved (2), `reject` sets rejected (3), and `reset` sets pending (1). `cancel` is a legacy alias for `reject`. Requires permission to update the booking to the target status.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let booking = client.bookings().answer(8, "approve")?;
/// println!("{}", booking.title);
/// # Ok(())
/// # }
/// ```
pub fn answer(&self, booking_id: impl Display, answer: impl Display) -> Result<models::BookingBase> {
let path = format!("/bookings/{}/{}", seg(booking_id), seg(answer));
let query: Query = Query::new();
self.client.request_data(Method::Put, &path, &query, None)
}
/// Create a resource booking
///
/// `POST /bookings`
///
/// Creates an independent booking for one resource. Requires permission to create bookings with the requested status. Resources with `needsAppointment=true` return 422. Automatic approval and conflicts can change the returned `statusId`.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-bookings");
/// let body = models::BookingCreate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// resource_id: 7,
/// show_in_cal: true,
/// status_id: 1,
/// title: "Band rehearsal".into(),
/// ..Default::default()
/// };
/// let result = client.bookings().create(&body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::BookingCreate) -> Result<models::BookingBase> {
let path = "/bookings".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a booking series
///
/// `DELETE /bookings/{bookingId}`
///
/// Deletes the complete booking, including all occurrences. To remove only an occurrence, update the independent booking’s exceptions or the linked appointment. Allowed for the booking creator, users with permission to administer bookings for the resource, or its resource administrators.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.bookings().delete(8)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, booking_id: impl Display) -> Result<()> {
let path = format!("/bookings/{}", seg(booking_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a booking series
///
/// `GET /bookings/{bookingId}`
///
/// Returns the stored booking and every calculated occurrence of its series, indexed by local start date. Requires permission to view its resource. Booking details may be anonymized. Use `include[]` to request conflicts or involved persons.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-bookings-id");
/// let booking = client.bookings().get(8)?;
/// println!("{:?}", booking);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, booking_id: impl Display) -> Result<models::BookingWithIncludes> {
self.get_with(booking_id, &Default::default())
}
/// Get a booking series
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /bookings/{bookingId}`
///
/// Returns the stored booking and every calculated occurrence of its series, indexed by local start date. Requires permission to view its resource. Booking details may be anonymized. Use `include[]` to request conflicts or involved persons.
pub fn get_with(&self, booking_id: impl Display, query: &GetBookingsIdQuery) -> Result<models::BookingWithIncludes> {
let path = format!("/bookings/{}", seg(booking_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List booking occurrences
///
/// `GET /bookings`
///
/// Returns occurrences overlapping the requested date range for the selected resources. The same recurring booking ID can appear more than once with different `booking.calculated` dates. `from` and `to` are inclusive local dates. Requires permission to view every selected resource. Booking details may be anonymized.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-bookings");
/// let query = GetBookingsQuery {
/// resource_ids: Some(vec![42]),
/// ..Default::default()
/// };
/// for booking in client.bookings().list(&query)? {
/// println!("{:?}", booking);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetBookingsQuery) -> Result<Vec<models::BookingCalculatedWithIncludes>> {
let path = "/bookings".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Preview conflicts for a new booking
///
/// `POST /bookings/conflicts`
///
/// Calculates overlapping occurrences of other pending or approved bookings for the proposed resource and schedule. Does not create a booking or reserve availability. Returns the conflicting occurrences, whose titles may be anonymized. Adjacent timed bookings do not conflict. Repeated overlaps can return the same conflicting occurrence more than once.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-bookings-conflicts");
/// let body = models::BookingConflictRequestBody {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// resource_id: 7,
/// ..Default::default()
/// };
/// for booking in client.bookings().preview_conflicts(&body)? {
/// println!("{}", booking.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn preview_conflicts(&self, body: &models::BookingConflictRequestBody) -> Result<Vec<models::BookingConflict>> {
let path = "/bookings/conflicts".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Preview conflicts for an existing booking
///
/// `POST /bookings/{bookingId}/conflicts`
///
/// Calculates conflicts for a replacement schedule using the stored booking’s resource. The booking itself is excluded; resourceId in the request is not used. Requires permission to update the booking. No changes are saved. Returns the conflicting occurrences, whose titles may be anonymized. Adjacent timed bookings do not conflict. Repeated overlaps can return the same conflicting occurrence more than once.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-bookings-id-conflicts");
/// let body = models::BookingConflictUpdate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// ..Default::default()
/// };
/// for booking in client.bookings().preview_conflicts_for(8, &body)? {
/// println!("{}", booking.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn preview_conflicts_for(&self, booking_id: impl Display, body: &models::BookingConflictUpdate) -> Result<Vec<models::BookingConflict>> {
let path = format!("/bookings/{}/conflicts", seg(booking_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Split and replace a booking occurrence
///
/// `POST /bookings/{bookingId}`
///
/// Removes one date or the remainder of an independent series and creates a replacement booking. `splitDate` identifies the original occurrence. Appointment-linked bookings cannot be split here. Requires permission to update the booking. Automatic approval and conflicts can change the returned `statusId`.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::BookingSplitCreate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// resource_id: 7,
/// show_in_cal: true,
/// status_id: 1,
/// title: "Band rehearsal".into(),
/// split_date: "2026-09-20".parse()?,
/// split_until_end: false,
/// ..Default::default()
/// };
/// let booking = client.bookings().split(8, &body)?;
/// println!("{}", booking.title);
/// # Ok(())
/// # }
/// ```
pub fn split(&self, booking_id: impl Display, body: &models::BookingSplitCreate) -> Result<models::BookingBase> {
let path = format!("/bookings/{}", seg(booking_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Update a resource booking
///
/// `PUT /bookings/{bookingId}`
///
/// Replaces an independent booking. For an appointment-linked booking, only `statusId` and `description` are processed; update its resource and schedule through the appointment APIs. Requires permission to update the booking. Automatic approval and conflicts can change the returned `statusId`.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-bookings-id");
/// let body = serde_json::json!({
/// "endDate": "2026-09-20T09:30:00Z",
/// "startDate": "2026-09-20T08:00:00Z",
/// "resourceId": 7,
/// "showInCal": true,
/// "statusId": 1,
/// "title": "Band rehearsal"
/// });
/// let result = client.bookings().update(8, &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, booking_id: impl Display, body: &serde_json::Value) -> Result<models::BookingBase> {
let path = format!("/bookings/{}", seg(booking_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.bulk_jobs()`
#[derive(Clone, Copy)]
pub struct BulkJobsResource<'a> {
client: &'a Client,
}
impl<'a> BulkJobsResource<'a> {
/// Enqueue a bulk operation
///
/// `POST /bulkjobs/{domainType}/{jobKey}/enqueue`
///
/// Queues the selected operation for targets allowed by its preflight permission check. Forbidden targets are omitted; remaining IDs retain order and duplicates. Each queued chunk normally contains up to 50 IDs, or 5 for group/delete. HTTP 201 confirms enqueueing, not successful execution, and can contain zero queued jobs. Each target is processed separately. Follow job or queue status using the returned identifiers.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::BulkJobCreate {
/// domain_object_identifiers: vec![serde_json::json!(42)],
/// job_data: serde_json::json!({}),
/// ..Default::default()
/// };
/// let bulk_job = client.bulk_jobs().enqueue("group", "setMaxMembers", &body)?;
/// println!("{}", bulk_job.job_group);
/// # Ok(())
/// # }
/// ```
pub fn enqueue(&self, domain_type: impl Display, job_key: impl Display, body: &models::BulkJobCreate) -> Result<models::BulkJobQueued> {
let path = format!("/bulkjobs/{}/{}/enqueue", seg(domain_type), seg(job_key));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Preview permitted bulk targets
///
/// `POST /bulkjobs/{domainType}/{jobKey}/infos`
///
/// Checks which supplied target identifiers the current user is allowed to process for the chosen job and payload. This is a read-only permission preview: it does not queue or execute the operation. Forbidden targets are silently omitted, while missing targets, invalid data and other errors may abort the whole request. Order and duplicate identifiers are retained. No reservation is made. See BulkJobCreate for domain/key mappings.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::BulkJobCreate {
/// domain_object_identifiers: vec![serde_json::json!(42)],
/// job_data: serde_json::json!({}),
/// ..Default::default()
/// };
/// let bulk_job = client.bulk_jobs().infos("group", "setMaxMembers", &body)?;
/// println!("{:?}", bulk_job);
/// # Ok(())
/// # }
/// ```
pub fn infos(&self, domain_type: impl Display, job_key: impl Display, body: &models::BulkJobCreate) -> Result<models::BulkInfos> {
let path = format!("/bulkjobs/{}/{}/infos", seg(domain_type), seg(job_key));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.bulk_letters()`
#[derive(Clone, Copy)]
pub struct BulkLettersResource<'a> {
client: &'a Client,
}
impl<'a> BulkLettersResource<'a> {
/// Create a bulkletter
///
/// `POST /bulkletters`
///
/// Schedules a mail-merge rendering job and starts the worker in the background. Requires edit bulkletter permission and access to the selected HTML template. Returns HTTP 200 with only {id}, plus a Location header for the job; it does not return the job object or finished PDF. Poll that URL until the job is DONE and has fileId/url. The final download is a ZIP containing individual PDFs. groupByHousehold groups exact addresses rather than family relationships.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::BulkletterCreate {
/// content: "<p>Hello [Spitzname]!</p>".into(),
/// group_by_household: true,
/// html_template_id: 39,
/// name: "Newsletter April 2025".into(),
/// person_ids: vec![13, 14],
/// ..Default::default()
/// };
/// let result = client.bulk_letters().create(&body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::BulkletterCreate) -> Result<models::BulkletterCreated> {
let path = "/bulkletters".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
/// Delete bulkletter
///
/// `DELETE /bulkletters/{id}`
///
/// Deletes the mail-merge job, its recipient rows, temporary rendering directory and generated ZIP file. Requires edit bulkletter permission and the same owner restriction as the detail read. No dry-run mode is supported. The operation does not coordinate with a currently running renderer.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.bulk_letters().delete(36)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
let path = format!("/bulkletters/{}", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Execute pending bulkletter jobs
///
/// `POST /bulkletters/execute`
///
/// Internal worker entry point, normally started automatically after creation. Processes up to ten recipient rows of the first unfinished mail-merge job, then starts another background request while work remains. Operates across creators. It renders separate PDFs and packages them into a ZIP; it does not send mail. A recently active worker causes this request to do no work. Returns 204 regardless of whether processing was skipped or a rendering exception was recorded as job status ERROR; inspect the job status for the result.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// client.bulk_letters().execute(&body)?;
/// # Ok(())
/// # }
/// ```
pub fn execute(&self, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<()> {
let path = "/bulkletters/execute".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Get bulkletter
///
/// `GET /bulkletters/{id}`
///
/// Reads one mail-merge job as a bare object, without a data wrapper. Requires edit bulkletter permission. Only the creator’s jobs and jobs with created_pid=0 are visible; other owners are reported as 404. The final file is a ZIP archive, not a combined PDF.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-bulkletters-id");
/// let bulk_letter = client.bulk_letters().get(36)?;
/// println!("{}", bulk_letter.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::Bulkletter> {
let path = format!("/bulkletters/{}", seg(id));
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
/// Get all bulkletters
///
/// `GET /bulkletters`
///
/// Lists the current user’s mail-merge jobs and jobs with created_pid=0. Requires edit bulkletter permission. Returns a bare array without data or meta; no pagination, status filter or ordering is defined.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-bulkletters");
/// for bulk_letter in client.bulk_letters().list()? {
/// println!("{}", bulk_letter.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Bulkletter>> {
let path = "/bulkletters".to_owned();
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
/// Get receivers of a bulkletter
///
/// `GET /bulkletters/{id}/persons`
///
/// Lists scheduled recipient persons whose person records the caller may view. Requires edit bulkletter or create print labels permission. Returns data only, without meta or pagination. Address fields reflect current person data. This endpoint does not apply the job-owner restriction of the detail read; a nonexistent job normally yields an empty list.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-bulkletters-id-persons");
/// for person in client.bulk_letters().list_persons(36)? {
/// println!("{:?}", person.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_persons(&self, id: impl Display) -> Result<Vec<models::BulkletterReceiver>> {
let path = format!("/bulkletters/{}/persons", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.calendars()`
#[derive(Clone, Copy)]
pub struct CalendarsResource<'a> {
client: &'a Client,
}
impl<'a> CalendarsResource<'a> {
pub fn appointments(&self) -> CalendarsAppointmentsResource<'a> {
CalendarsAppointmentsResource { client: self.client }
}
pub fn meeting_request(&self) -> CalendarsMeetingRequestResource<'a> {
CalendarsMeetingRequestResource { client: self.client }
}
/// Create a calendar
///
/// `POST /calendars`
///
/// Creates a calendar of the chosen type. church requires permission to administer church calendars; group and personal require permission to create or administer their respective category. The creator receives permission to edit appointments in the new calendar. Optional iCalSourceUrl starts an immediate external-feed import.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-calendars");
/// let body = models::CalendarCreate {
/// name: "Community events".into(),
/// sort_key: 10,
/// r#type: "church".into(),
/// ..Default::default()
/// };
/// let result = client.calendars().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::CalendarCreate) -> Result<models::Calendar> {
let path = "/calendars".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a calendar and its contents
///
/// `DELETE /calendars/{calendarId}`
///
/// Deletes the calendar and its appointment contents, and removes permissions attached to that calendar. Requires edit-category permission for the calendar or ownership as its creator. Deletion can be blocked by references, including agenda templates belonging to the calendar; 409 returns the blocking references.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.calendars().delete(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, calendar_id: impl Display) -> Result<()> {
let path = format!("/calendars/{}", seg(calendar_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get calendar settings
///
/// `GET /calendars/{calendarId}`
///
/// Returns one calendar’s settings. Reading is allowed with view-category or edit-category permission for the calendar, or for its creator. This creator check is additional to the permission filter used by GET /calendars. Use /calendars/{calendarId}/appointments to retrieve occurrences.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-calendarId");
/// let calendar = client.calendars().get(42)?;
/// println!("{}", calendar.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, calendar_id: impl Display) -> Result<models::Calendar> {
let path = format!("/calendars/{}", seg(calendar_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List calendars accessible through calendar permissions
///
/// `GET /calendars`
///
/// Returns calendars for which the current user has view-category or edit-category permission, ordered by sortKey ascending.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars");
/// for calendar in client.calendars().list()? {
/// println!("{}", calendar.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Calendar>> {
let path = "/calendars".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get candidates for a meeting request (deprecated)
///
/// `GET /calendars/{calendarId}/meetingrequestpersons`
///
/// Deprecated alias for /calendars/{calendarId}/meetingrequest/candidates. Returns the same visible candidates.
///
/// Use [`Self::list_meeting_request_persons_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-calendarId-meetingrequestpersons");
/// for meeting_request_person in client.calendars().list_meeting_request_persons(42)? {
/// println!("{:?}", meeting_request_person.group_name);
/// }
/// # Ok(())
/// # }
/// ```
#[deprecated = "GET /calendars/{calendarId}/meetingrequestpersons is deprecated in the ChurchTools API."]
pub fn list_meeting_request_persons(&self, calendar_id: impl Display) -> Result<Vec<models::MeetingRequestCandidate>> {
self.list_meeting_request_persons_with(calendar_id, &Default::default())
}
/// Get candidates for a meeting request (deprecated)
///
/// Like [`Self::list_meeting_request_persons`], with query parameters.
///
/// `GET /calendars/{calendarId}/meetingrequestpersons`
///
/// Deprecated alias for /calendars/{calendarId}/meetingrequest/candidates. Returns the same visible candidates.
#[deprecated = "GET /calendars/{calendarId}/meetingrequestpersons is deprecated in the ChurchTools API."]
pub fn list_meeting_request_persons_with(&self, calendar_id: impl Display, query: &GetCalendarsCalendarIdMeetingrequestpersonsQuery) -> Result<Vec<models::MeetingRequestCandidate>> {
let path = format!("/calendars/{}/meetingrequestpersons", seg(calendar_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update calendar settings
///
/// `PUT /calendars/{calendarId}`
///
/// Replaces editable calendar settings while preserving the calendar type. Requires administration permission for the calendar’s type or ownership as its creator; permission to edit appointments alone is not sufficient. iCalSourceUrl triggers an external calendar import.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-calendars-calendarId");
/// let body = models::CalendarUpdate {
/// name: "Community events".into(),
/// sort_key: 10,
/// ..Default::default()
/// };
/// let result = client.calendars().update(42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, calendar_id: impl Display, body: &models::CalendarUpdate) -> Result<models::Calendar> {
let path = format!("/calendars/{}", seg(calendar_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.calendars().appointments()`
#[derive(Clone, Copy)]
pub struct CalendarsAppointmentsResource<'a> {
client: &'a Client,
}
impl<'a> CalendarsAppointmentsResource<'a> {
pub fn meeting_requests(&self) -> CalendarsAppointmentsMeetingRequestsResource<'a> {
CalendarsAppointmentsMeetingRequestsResource { client: self.client }
}
pub fn templates(&self) -> CalendarsAppointmentsTemplatesResource<'a> {
CalendarsAppointmentsTemplatesResource { client: self.client }
}
/// Preview impacts of an appointment schedule change
///
/// `POST /calendars/{calendarId}/appointments/{appointmentId}/changeimpact`
///
/// Calculates supported event, service-assignment and resource-booking impacts of the proposed schedule without saving the appointment.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-calendars-calendarId-appointments-appointmentId-changeimpact");
/// let body = models::AppointmentChangeImpactCreate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// ..Default::default()
/// };
/// for appointment in client.calendars().appointments().change_impact(42, 4, &body)? {
/// println!("{:?}", appointment);
/// }
/// # Ok(())
/// # }
/// ```
pub fn change_impact(&self, calendar_id: impl Display, appointment_id: impl Display, body: &models::AppointmentChangeImpactCreate) -> Result<Vec<serde_json::Value>> {
let path = format!("/calendars/{}/appointments/{}/changeimpact", seg(calendar_id), seg(appointment_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Create an appointment or series
///
/// `POST /calendars/{calendarId}/appointments`
///
/// Creates a calendar appointment, with optional recurrence, resource reservations, service-planning events and meeting invitations. calendarId comes from the path. Creating registration groups and linked resources requires the corresponding permissions.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-calendars-calendarId-appointments");
/// let body = models::AppointmentCreate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// is_internal: true,
/// title: "Sunday service".into(),
/// ..Default::default()
/// };
/// let result = client.calendars().appointments().create(42, &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, calendar_id: impl Display, body: &models::AppointmentCreate) -> Result<models::AppointmentBase> {
let path = format!("/calendars/{}/appointments", seg(calendar_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete an appointment or entire series
///
/// `DELETE /calendars/{calendarId}/appointments/{appointmentId}`
///
/// Deletes the stored appointment and triggers the cleanup of linked resources. For recurring appointments this removes the whole series. To remove only one occurrence, update the complete series with that local date in exceptions. This requires calendar editing permission or being the appointment’s last editor.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.calendars().appointments().delete(42, 4)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, calendar_id: impl Display, appointment_id: impl Display) -> Result<()> {
let path = format!("/calendars/{}/appointments/{}", seg(calendar_id), seg(appointment_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get an appointment series and its dates
///
/// `GET /calendars/{calendarId}/appointments/{appointmentId}`
///
/// Returns the stored appointment and all dates calculated from its recurrence settings. calculatedDates is keyed by local start date and contains UTC start/end timestamps even for all-day appointments. This differs from the date-or-timestamp format used by occurrence endpoints.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-calendarId-appointments-appointmentId");
/// let appointment = client.calendars().appointments().get(42, 4)?;
/// println!("{:?}", appointment);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, calendar_id: impl Display, appointment_id: impl Display) -> Result<models::AppointmentCalculated> {
self.get_with(calendar_id, appointment_id, &Default::default())
}
/// Get an appointment series and its dates
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /calendars/{calendarId}/appointments/{appointmentId}`
///
/// Returns the stored appointment and all dates calculated from its recurrence settings. calculatedDates is keyed by local start date and contains UTC start/end timestamps even for all-day appointments. This differs from the date-or-timestamp format used by occurrence endpoints.
pub fn get_with(&self, calendar_id: impl Display, appointment_id: impl Display, query: &GetCalendarsCalendarIdAppointmentsAppointmentIdQuery) -> Result<models::AppointmentCalculated> {
let path = format!("/calendars/{}/appointments/{}", seg(calendar_id), seg(appointment_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Export an appointment or series as iCalendar
///
/// `GET /calendars/{calendarId}/appointments/{appointmentId}/ical`
///
/// Downloads appointment.ics as text/calendar. The export includes recurrence rules, excluded dates and additional dates; it may contain multiple VEVENT entries for additional recurring or standalone dates. This exports the stored appointment/series, not a selected occurrence.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.calendars().appointments().get_ical(42, 4)?;
/// std::fs::write("ergebnis.ics", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_ical(&self, calendar_id: impl Display, appointment_id: impl Display) -> Result<Vec<u8>> {
let path = format!("/calendars/{}/appointments/{}/ical", seg(calendar_id), seg(appointment_id));
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None)
}
/// Get one appointment occurrence
///
/// `GET /calendars/appointments/{appointmentId}/{startDate}`
///
/// Returns the occurrence starting on the specified local date. appointment.base describes the stored series and appointment.calculated describes this occurrence. Returns 404 if no matching occurrence is available.
///
/// Use [`Self::get_occurrence_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-appointments-appointmentId-startDate");
/// let occurrence = client.calendars().appointments().get_occurrence(4, "2026-09-20")?;
/// println!("{:?}", occurrence.title_suffix);
/// # Ok(())
/// # }
/// ```
pub fn get_occurrence(&self, appointment_id: impl Display, start_date: impl Display) -> Result<models::AppointmentOccurrence> {
self.get_occurrence_with(appointment_id, start_date, &Default::default())
}
/// Get one appointment occurrence
///
/// Like [`Self::get_occurrence`], with query parameters.
///
/// `GET /calendars/appointments/{appointmentId}/{startDate}`
///
/// Returns the occurrence starting on the specified local date. appointment.base describes the stored series and appointment.calculated describes this occurrence. Returns 404 if no matching occurrence is available.
pub fn get_occurrence_with(&self, appointment_id: impl Display, start_date: impl Display, query: &GetCalendarsAppointmentsAppointmentIdStartDateQuery) -> Result<models::AppointmentOccurrence> {
let path = format!("/calendars/appointments/{}/{}", seg(appointment_id), seg(start_date));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get one appointment occurrence
///
/// `GET /calendars/{calendarId}/appointments/{appointmentId}/{startDate}`
///
/// Returns the occurrence starting on the specified local date. appointment.base describes the stored series and appointment.calculated describes this occurrence. Returns 404 if no matching occurrence is available.
///
/// Use [`Self::get_occurrence_in_calendar_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-calendarId-appointments-appointmentId-startDate");
/// let occurrence_in_calendar = client.calendars().appointments().get_occurrence_in_calendar(42, 4, "2026-09-20")?;
/// println!("{:?}", occurrence_in_calendar.title_suffix);
/// # Ok(())
/// # }
/// ```
pub fn get_occurrence_in_calendar(&self, calendar_id: impl Display, appointment_id: impl Display, start_date: impl Display) -> Result<models::AppointmentOccurrence> {
self.get_occurrence_in_calendar_with(calendar_id, appointment_id, start_date, &Default::default())
}
/// Get one appointment occurrence
///
/// Like [`Self::get_occurrence_in_calendar`], with query parameters.
///
/// `GET /calendars/{calendarId}/appointments/{appointmentId}/{startDate}`
///
/// Returns the occurrence starting on the specified local date. appointment.base describes the stored series and appointment.calculated describes this occurrence. Returns 404 if no matching occurrence is available.
pub fn get_occurrence_in_calendar_with(&self, calendar_id: impl Display, appointment_id: impl Display, start_date: impl Display, query: &GetCalendarsCalendarIdAppointmentsAppointmentIdStartDateQuery) -> Result<models::AppointmentOccurrence> {
let path = format!("/calendars/{}/appointments/{}/{}", seg(calendar_id), seg(appointment_id), seg(start_date));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List appointment occurrences across calendars
///
/// `GET /calendars/appointments`
///
/// Returns calculated occurrences for the requested date range, with one entry per occurrence rather than per series. Use appointment.base for the stored series and appointment.calculated for the displayed dates. Recurring occurrences use the installation’s local time across daylight-saving changes. Anonymous users receive only non-internal appointments in calendars they may view.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-appointments");
/// let query = GetCalendarsAppointmentsQuery {
/// calendar_ids: Some(vec![2, 3]),
/// ..Default::default()
/// };
/// for appointment in client.calendars().appointments().list(&query)? {
/// println!("{:?}", appointment.title_suffix);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetCalendarsAppointmentsQuery) -> Result<Vec<models::AppointmentOccurrenceList>> {
let path = "/calendars/appointments".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List appointment occurrences in a calendar
///
/// `GET /calendars/{calendarId}/appointments`
///
/// Returns calculated occurrences for the requested date range, with one entry per occurrence rather than per series. Use appointment.base for the stored series and appointment.calculated for the displayed dates. Recurring occurrences use the installation’s local time across daylight-saving changes. Anonymous users receive only non-internal appointments in calendars they may view.
///
/// Use [`Self::list_in_calendar_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-calendarId-appointments");
/// for in_calendar in client.calendars().appointments().list_in_calendar(42)? {
/// println!("{:?}", in_calendar.title_suffix);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_in_calendar(&self, calendar_id: impl Display) -> Result<Vec<models::AppointmentOccurrenceList>> {
self.list_in_calendar_with(calendar_id, &Default::default())
}
/// List appointment occurrences in a calendar
///
/// Like [`Self::list_in_calendar`], with query parameters.
///
/// `GET /calendars/{calendarId}/appointments`
///
/// Returns calculated occurrences for the requested date range, with one entry per occurrence rather than per series. Use appointment.base for the stored series and appointment.calculated for the displayed dates. Recurring occurrences use the installation’s local time across daylight-saving changes. Anonymous users receive only non-internal appointments in calendars they may view.
pub fn list_in_calendar_with(&self, calendar_id: impl Display, query: &GetCalendarsCalendarIdAppointmentsQuery) -> Result<Vec<models::AppointmentOccurrenceList>> {
let path = format!("/calendars/{}/appointments", seg(calendar_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Split and update an appointment series
///
/// `POST /calendars/{calendarId}/appointments/{appointmentId}`
///
/// Creates a new stored appointment from the supplied complete data and removes the selected scope from the original. splitUntilEnd=true cuts the original off before splitDate and requires a split after the original start. false excludes only splitDate and allows splitting the first occurrence. The returned data.id belongs to the new appointment. The new recurrence must describe the intended replacement; splitting does not automatically restrict it to one date. Linked resources are adjusted by their respective workflows.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AppointmentSplitUpdate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// is_internal: true,
/// title: "Sunday service".into(),
/// split_date: "2026-10-04".parse()?,
/// split_until_end: true,
/// ..Default::default()
/// };
/// let appointment = client.calendars().appointments().split(42, 4, &body)?;
/// println!("{}", appointment.title);
/// # Ok(())
/// # }
/// ```
pub fn split(&self, calendar_id: impl Display, appointment_id: impl Display, body: &models::AppointmentSplitUpdate) -> Result<models::AppointmentBase> {
let path = format!("/calendars/{}/appointments/{}", seg(calendar_id), seg(appointment_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Update an appointment or series
///
/// `PUT /calendars/{calendarId}/appointments/{appointmentId}`
///
/// Replaces editable base fields and the schedule of the stored appointment. This affects the entire series. Existing events and bookings follow the changed schedule. Use changeimpact to inspect supported consequences before submitting a schedule change.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-calendars-calendarId-appointments-appointmentId");
/// let body = models::AppointmentUpdate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// is_internal: true,
/// title: "Sunday service".into(),
/// ..Default::default()
/// };
/// let result = client.calendars().appointments().update(42, 4, &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, calendar_id: impl Display, appointment_id: impl Display, body: &models::AppointmentUpdate) -> Result<models::AppointmentBase> {
let path = format!("/calendars/{}/appointments/{}", seg(calendar_id), seg(appointment_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.calendars().appointments().meeting_requests()`
#[derive(Clone, Copy)]
pub struct CalendarsAppointmentsMeetingRequestsResource<'a> {
client: &'a Client,
}
impl<'a> CalendarsAppointmentsMeetingRequestsResource<'a> {
/// Answer a meeting invitation
///
/// `POST /calendars/{calendarId}/appointments/{appointmentId}/meetingrequests/{meetingRequestId}/{answer}`
///
/// Records the answer of the invited person. accept, decline and tentative set the corresponding state; reset returns the request to pending. maybe remains accepted as a deprecated alias for tentative. Only the invitee may answer.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.calendars().appointments().meeting_requests().answer(42, 4, 19, "accept")?;
/// # Ok(())
/// # }
/// ```
pub fn answer(&self, calendar_id: impl Display, appointment_id: impl Display, meeting_request_id: impl Display, answer: impl Display) -> Result<()> {
let path = format!("/calendars/{}/appointments/{}/meetingrequests/{}/{}", seg(calendar_id), seg(appointment_id), seg(meeting_request_id), seg(answer));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Invite a person to an appointment
///
/// `POST /calendars/{calendarId}/appointments/{appointmentId}/meetingrequests`
///
/// Creates a meeting invitation for inviteeId. Requires permission to edit the appointment and view the invited person. The inviter is onBehalfOfPid when set, otherwise the current user. An invitation to the inviter is automatically accepted.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::MeetingRequestCreate {
/// invitee_id: 42,
/// ..Default::default()
/// };
/// let result = client.calendars().appointments().meeting_requests().create(42, 4, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, calendar_id: impl Display, appointment_id: impl Display, body: &models::MeetingRequestCreate) -> Result<models::MeetingRequest> {
let path = format!("/calendars/{}/appointments/{}/meetingrequests", seg(calendar_id), seg(appointment_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
/// Delete a meeting invitation
///
/// `DELETE /calendars/{calendarId}/appointments/{appointmentId}/meetingrequests/{meetingRequestId}`
///
/// Removes a meeting request. This requires permission to edit the appointment; invitees can use the answer endpoint to decline instead.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.calendars().appointments().meeting_requests().delete(42, 4, 19)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, calendar_id: impl Display, appointment_id: impl Display, meeting_request_id: impl Display) -> Result<()> {
let path = format!("/calendars/{}/appointments/{}/meetingrequests/{}", seg(calendar_id), seg(appointment_id), seg(meeting_request_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// List meeting invitations for an appointment
///
/// `GET /calendars/{calendarId}/appointments/{appointmentId}/meetingrequests`
///
/// Returns all meeting requests associated with the stored appointment/series. Requests are not per-occurrence attendance records.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-calendarId-appointments-appointmentId-meetingrequests");
/// for meeting_request in client.calendars().appointments().meeting_requests().list(42, 4)? {
/// println!("{}", meeting_request.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, calendar_id: impl Display, appointment_id: impl Display) -> Result<Vec<models::MeetingRequest>> {
let path = format!("/calendars/{}/appointments/{}/meetingrequests", seg(calendar_id), seg(appointment_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Answer a meeting invitation
///
/// `PUT /calendars/{calendarId}/appointments/{appointmentId}/meetingrequests/{meetingRequestId}`
///
/// Legacy body-based endpoint for answering a meeting request. Only the invited person may answer. Use POST on the path ending in /{answer}.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::MeetingRequestUpdate {
/// answer: "accept".into(),
/// ..Default::default()
/// };
/// client.calendars().appointments().meeting_requests().update(42, 4, 19, &body)?;
/// # Ok(())
/// # }
/// ```
#[deprecated = "PUT /calendars/{calendarId}/appointments/{appointmentId}/meetingrequests/{meetingRequestId} is deprecated in the ChurchTools API. Use POST on the path ending in /{answer}."]
pub fn update(&self, calendar_id: impl Display, appointment_id: impl Display, meeting_request_id: impl Display, body: &models::MeetingRequestUpdate) -> Result<()> {
let path = format!("/calendars/{}/appointments/{}/meetingrequests/{}", seg(calendar_id), seg(appointment_id), seg(meeting_request_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.calendars().appointments().templates()`
#[derive(Clone, Copy)]
pub struct CalendarsAppointmentsTemplatesResource<'a> {
client: &'a Client,
}
impl<'a> CalendarsAppointmentsTemplatesResource<'a> {
/// Create an appointment template
///
/// `POST /calendars/appointments/templates`
///
/// Stores reusable defaults for future appointments. Requires permission to edit calendar entry templates for the selected calendar.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-calendars-appointments-templates");
/// let body = models::AppointmentTemplateCreate {
/// calendar_id: 1,
/// duration: 3600,
/// start_time: "10:00".into(),
/// title: "Service".into(),
/// ..Default::default()
/// };
/// let result = client.calendars().appointments().templates().create(&body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::AppointmentTemplateCreate) -> Result<models::AppointmentTemplateWritten> {
let path = "/calendars/appointments/templates".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete an appointment template
///
/// `DELETE /calendars/appointments/templates/{templateId}`
///
/// Deletes the reusable template and its associated image files. Requires permission to edit appointment templates in its calendar.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.calendars().appointments().templates().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, template_id: impl Display) -> Result<()> {
let path = format!("/calendars/appointments/templates/{}", seg(template_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get an appointment template
///
/// `GET /calendars/appointments/templates/{templateId}`
///
/// Returns the saved defaults of one template, including its ID and metadata.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-appointments-templates-id");
/// let template = client.calendars().appointments().templates().get(1)?;
/// println!("{:?}", template.title);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, template_id: impl Display) -> Result<models::AppointmentTemplate> {
let path = format!("/calendars/appointments/templates/{}", seg(template_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List appointment templates
///
/// `GET /calendars/appointments/templates`
///
/// Returns all saved appointment templates and their reusable defaults.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-appointments-templates");
/// for template in client.calendars().appointments().templates().list()? {
/// println!("{:?}", template.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::AppointmentTemplate>> {
let path = "/calendars/appointments/templates".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update an appointment template
///
/// `PUT /calendars/appointments/templates/{templateId}`
///
/// Replaces the template’s saved defaults. Permission is checked for the calendar selected by calendarId.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-calendars-appointments-templates-id");
/// let body = models::AppointmentTemplateUpdate {
/// calendar_id: 1,
/// duration: 3600,
/// start_time: "10:00".into(),
/// title: "Service".into(),
/// ..Default::default()
/// };
/// let result = client.calendars().appointments().templates().update(1, &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, template_id: impl Display, body: &models::AppointmentTemplateUpdate) -> Result<models::AppointmentTemplateWritten> {
let path = format!("/calendars/appointments/templates/{}", seg(template_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.calendars().meeting_request()`
#[derive(Clone, Copy)]
pub struct CalendarsMeetingRequestResource<'a> {
client: &'a Client,
}
impl<'a> CalendarsMeetingRequestResource<'a> {
/// Get candidates for a meeting request
///
/// `GET /calendars/{calendarId}/meetingrequest/candidates`
///
/// Returns visible people with direct, person-status, group-derived, or group-type-derived calendar permissions. When appointmentId is supplied, visible invitees already associated with that appointment are also included.
///
/// Use [`Self::list_candidates_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-calendars-calendarId-meetingrequest-candidates");
/// for candidate in client.calendars().meeting_request().list_candidates(42)? {
/// println!("{:?}", candidate.group_name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_candidates(&self, calendar_id: impl Display) -> Result<Vec<models::MeetingRequestCandidate>> {
self.list_candidates_with(calendar_id, &Default::default())
}
/// Get candidates for a meeting request
///
/// Like [`Self::list_candidates`], with query parameters.
///
/// `GET /calendars/{calendarId}/meetingrequest/candidates`
///
/// Returns visible people with direct, person-status, group-derived, or group-type-derived calendar permissions. When appointmentId is supplied, visible invitees already associated with that appointment are also included.
pub fn list_candidates_with(&self, calendar_id: impl Display, query: &GetCalendarsCalendarIdMeetingrequestCandidatesQuery) -> Result<Vec<models::MeetingRequestCandidate>> {
let path = format!("/calendars/{}/meetingrequest/candidates", seg(calendar_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.campuses()`
#[derive(Clone, Copy)]
pub struct CampusesResource<'a> {
client: &'a Client,
}
impl<'a> CampusesResource<'a> {
/// Create new campus
///
/// `POST /campuses`
///
/// Save new campus
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-campuses");
/// let body = models::CampusCreate {
/// name: "Hamburg Altona".into(),
/// shorty: "ALT".into(),
/// ..Default::default()
/// };
/// let result = client.campuses().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::CampusCreate) -> Result<models::Campus> {
let path = "/campuses".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a campus
///
/// `DELETE /campuses/{id}`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.campuses().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
let path = format!("/campuses/{}", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a campus
///
/// `GET /campuses/{id}`
///
/// Get a specific campus
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-campuses-id");
/// let campus = client.campuses().get(1)?;
/// println!("{}", campus.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::Campus> {
let path = format!("/campuses/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all campuses
///
/// `GET /campuses`
///
/// Returns an array of all campuses defined in ChurchTools. Campuses are sorted by its `sortKey` by default.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-campuses");
/// for campus in client.campuses().list()? {
/// println!("{}", campus.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Campus>> {
let path = "/campuses".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update campus
///
/// `PUT /campuses/{id}`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-campuses-id");
/// let body = models::CampusUpdate {
/// name: Some(Some("Hauskreis Nord".into())),
/// ..Default::default()
/// };
/// let result = client.campuses().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::CampusUpdate) -> Result<models::Campus> {
let path = format!("/campuses/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.captcha()`
#[derive(Clone, Copy)]
pub struct CaptchaResource<'a> {
client: &'a Client,
}
impl<'a> CaptchaResource<'a> {
/// Altcha Captcha Verification
///
/// `POST /captcha`
///
/// Verify a captcha solution. Only for testing purposes. Other endpoints that require a captcha take the solution directly. See <https://altcha.org/docs/website-integration/> for more information
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostCaptchaBody {
/// solution: "beispiel".into(),
/// ..Default::default()
/// };
/// let result = client.captcha().create(&body)?;
/// println!("{}", result.is_valid);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::PostCaptchaBody) -> Result<models::PostCaptchaResponse> {
let path = "/captcha".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
/// Altcha Captcha Challenge
///
/// `GET /captcha`
///
/// Get a new challenge to solve. To be used with <https://altcha.org/docs/website-integration/>
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-captcha");
/// let captcha = client.captcha().get()?;
/// println!("{}", captcha.signature);
/// # Ok(())
/// # }
/// ```
pub fn get(&self) -> Result<models::GetCaptchaResponse> {
let path = "/captcha".to_owned();
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
}
/// `client.chat()`
#[derive(Clone, Copy)]
pub struct ChatResource<'a> {
client: &'a Client,
}
impl<'a> ChatResource<'a> {
/// Start new chat
///
/// `POST /chat`
///
/// Starts synchronization of a chat room with Matrix. New rooms have `STARTING` status and record the current user as creator.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ChatCreate {
/// domain_id: 9,
/// guid: "681F54E3-2EB7-40A4-84F0-EFF8E8F05727".into(),
/// prefix: "ctg".into(),
/// roomname: "Technical team".into(),
/// ..Default::default()
/// };
/// let result = client.chat().create(&body)?;
/// println!("{:?}", result.creator);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ChatCreate) -> Result<models::Chat> {
let path = "/chat".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a chat
///
/// `DELETE /chat/{guid}`
///
/// Deletes the local chat room record. A missing record is treated as already deleted.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.chat().delete("681F54E3-2EB7-40A4-84F0-EFF8E8F05727")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, guid: impl Display) -> Result<()> {
self.delete_with(guid, &Default::default())
}
/// Delete a chat
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /chat/{guid}`
///
/// Deletes the local chat room record. A missing record is treated as already deleted.
pub fn delete_with(&self, guid: impl Display, query: &DeleteChatGuidQuery) -> Result<()> {
let path = format!("/chat/{}", seg(guid));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get all chats
///
/// `GET /chat`
///
/// Returns all chat rooms, or only rooms matching the supplied synchronization token.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-chat");
/// for chat in client.chat().list()? {
/// println!("{:?}", chat.creator);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Chat>> {
self.list_with(&Default::default())
}
/// Get all chats
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /chat`
///
/// Returns all chat rooms, or only rooms matching the supplied synchronization token.
pub fn list_with(&self, query: &GetChatQuery) -> Result<Vec<models::Chat>> {
let path = "/chat".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a chat
///
/// `PATCH /chat/{guid}`
///
/// Updates chat room metadata or requests a lifecycle transition.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ChatUpdate {
/// creator: Some(1),
/// ..Default::default()
/// };
/// let result = client.chat().patch("681F54E3-2EB7-40A4-84F0-EFF8E8F05727", &body)?;
/// println!("{:?}", result.creator);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, guid: impl Display, body: &models::ChatUpdate) -> Result<models::Chat> {
let path = format!("/chat/{}", seg(guid));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
}
/// `client.checkin()`
#[derive(Clone, Copy)]
pub struct CheckinResource<'a> {
client: &'a Client,
}
impl<'a> CheckinResource<'a> {
/// Create new person and add to group
///
/// `POST /checkin/persons`
///
/// Creates a person and admits them to a group for the check-in workflow. Requires administer persons, or create person in churchcheckin plus group meeting permission and a person security level covering the selected status. Masterdata IDs are installation-specific. Ordinary duplicate-person confirmation is bypassed; a unique GUID and license limits still apply. A creation note and optional tag are saved before the membership. This request does not record meeting attendance or print a label; perform the actual check-in separately. Failure can leave earlier steps saved because the whole workflow is not one transaction. The response is the legacy person model, not the regular Person representation.
///
/// Use [`Self::create_persons_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::CheckinPersonCreate {
/// group: models::CheckinMembershipCreate {
/// id: 9,
/// person_fields: Default::default(),
/// ..Default::default()
/// },
/// person: models::CheckinPersonDataCreate {
/// campus_id: 42,
/// department_ids: vec![42],
/// first_name: Some("Alex".into()),
/// last_name: "Example".into(),
/// status_id: 42,
/// ..Default::default()
/// },
/// ..Default::default()
/// };
/// let result = client.checkin().create_persons(&body)?;
/// println!("{:?}", result.first_name);
/// # Ok(())
/// # }
/// ```
pub fn create_persons(&self, body: &models::CheckinPersonCreate) -> Result<models::CheckinPerson> {
self.create_persons_with(&Default::default(), body)
}
/// Create new person and add to group
///
/// Like [`Self::create_persons`], with query parameters.
///
/// `POST /checkin/persons`
///
/// Creates a person and admits them to a group for the check-in workflow. Requires administer persons, or create person in churchcheckin plus group meeting permission and a person security level covering the selected status. Masterdata IDs are installation-specific. Ordinary duplicate-person confirmation is bypassed; a unique GUID and license limits still apply. A creation note and optional tag are saved before the membership. This request does not record meeting attendance or print a label; perform the actual check-in separately. Failure can leave earlier steps saved because the whole workflow is not one transaction. The response is the legacy person model, not the regular Person representation.
pub fn create_persons_with(&self, query: &PostCheckinPersonsQuery, body: &models::CheckinPersonCreate) -> Result<models::CheckinPerson> {
let path = "/checkin/persons".to_owned();
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Put existing person into group
///
/// `PUT /checkin/persons`
///
/// Admits an existing person to a group using its default role and check-in membership origin, optionally adds a tag, and updates person fields configured for that group. Requires administer persons or group meeting permission. Existing membership is a conflict, not an idempotent success. The operation does not record attendance or print labels. Tag changes occur before membership creation and can remain after a failed request. The returned legacy person-model representation differs from the regular Person API.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::CheckinPersonUpdate {
/// group: models::CheckinMembershipCreate {
/// id: 9,
/// person_fields: Default::default(),
/// ..Default::default()
/// },
/// person_id: 42,
/// ..Default::default()
/// };
/// let result = client.checkin().update_persons(&body)?;
/// println!("{:?}", result.first_name);
/// # Ok(())
/// # }
/// ```
pub fn update_persons(&self, body: &models::CheckinPersonUpdate) -> Result<models::CheckinPerson> {
let path = "/checkin/persons".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.church_query()`
#[derive(Clone, Copy)]
pub struct ChurchQueryResource<'a> {
client: &'a Client,
}
impl<'a> ChurchQueryResource<'a> {
pub fn debug(&self) -> ChurchQueryDebugResource<'a> {
ChurchQueryDebugResource { client: self.client }
}
/// Get masterdata for ChurchQuery
///
/// `GET /churchquery/metadata`
///
/// Use [`Self::get_metadata_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-churchquery-metadata");
/// let result = client.church_query().get_metadata()?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_metadata(&self) -> Result<serde_json::Value> {
self.get_metadata_with(&Default::default())
}
/// Get masterdata for ChurchQuery
///
/// Like [`Self::get_metadata`], with query parameters.
///
/// `GET /churchquery/metadata`
pub fn get_metadata_with(&self, query: &GetChurchqueryMetadataQuery) -> Result<serde_json::Value> {
let path = "/churchquery/metadata".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.church_query().debug()`
#[derive(Clone, Copy)]
pub struct ChurchQueryDebugResource<'a> {
client: &'a Client,
}
impl<'a> ChurchQueryDebugResource<'a> {
/// Export result of ChurchQuery
///
/// `POST /churchquery/debug/export`
///
/// **Caution**: This is an preliminary API, and is subject to be changed. It provides a downloadfile with the result of a given query.
///
/// Use [`Self::export_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: String = "beispiel".into();
/// client.church_query().debug().export(&body)?;
/// # Ok(())
/// # }
/// ```
pub fn export(&self, body: &String) -> Result<()> {
self.export_with(&Default::default(), body)
}
/// Export result of ChurchQuery
///
/// Like [`Self::export`], with query parameters.
///
/// `POST /churchquery/debug/export`
///
/// **Caution**: This is an preliminary API, and is subject to be changed. It provides a downloadfile with the result of a given query.
pub fn export_with(&self, query: &PostChurchqueryDebugExportQuery, body: &String) -> Result<()> {
let path = "/churchquery/debug/export".to_owned();
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.config()`
#[derive(Clone, Copy)]
pub struct ConfigResource<'a> {
client: &'a Client,
}
impl<'a> ConfigResource<'a> {
/// Get the ChurchTools-Config
///
/// `GET /config`
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-config");
/// let config = client.config().get()?;
/// println!("{:?}", config.current_config_file);
/// # Ok(())
/// # }
/// ```
pub fn get(&self) -> Result<models::GetConfigResponse> {
self.get_with(&Default::default())
}
/// Get the ChurchTools-Config
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /config`
pub fn get_with(&self, query: &GetConfigQuery) -> Result<models::GetConfigResponse> {
let path = "/config".to_owned();
let query: Query = query.to_query();
self.client.request_json(Method::Get, &path, &query, None)
}
/// Change the ChurchTools-Config
///
/// `PUT /config`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PutConfigRequest {
/// accept_datasecurity: Some(true),
/// ..Default::default()
/// };
/// client.config().update(&body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, body: &models::PutConfigRequest) -> Result<()> {
let path = "/config".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.contact_labels()`
#[derive(Clone, Copy)]
pub struct ContactLabelsResource<'a> {
client: &'a Client,
}
impl<'a> ContactLabelsResource<'a> {
/// Create new Contact Label
///
/// `POST /contactlabels`
///
/// Creates a reusable email contact label. Requires "edit masterdata" permission in `churchdb`. Setting `isDefault` to `true` replaces the existing default.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-contactlabels");
/// let body = models::ContactLabelCreate {
/// is_default: false,
/// name: "Private".into(),
/// sort_key: 10,
/// ..Default::default()
/// };
/// let result = client.contact_labels().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ContactLabelCreate) -> Result<models::ContactLabel> {
let path = "/contactlabels".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete Contact Label
///
/// `DELETE /contactlabels/{id}`
///
/// Deletes an email contact label. Requires "edit masterdata" permission in `churchdb`. Email-address references can block deletion.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.contact_labels().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete Contact Label
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /contactlabels/{id}`
///
/// Deletes an email contact label. Requires "edit masterdata" permission in `churchdb`. Email-address references can block deletion.
pub fn delete_with(&self, id: impl Display, query: &DeleteContactlabelsIdQuery) -> Result<()> {
let path = format!("/contactlabels/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get Contact Label
///
/// `GET /contactlabels/{id}`
///
/// Returns a contact-label definition, including its translated display name and default flag.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-contactlabels-id");
/// let contact_label = client.contact_labels().get(1)?;
/// println!("{}", contact_label.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::ContactLabel> {
let path = format!("/contactlabels/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get All Contact Labels
///
/// `GET /contactlabels`
///
/// Returns all email contact labels, ordered by `sortKey` and then `name`, both ascending. Labels classify addresses such as private and work.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-contactlabels");
/// for contact_label in client.contact_labels().list()? {
/// println!("{}", contact_label.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::ContactLabel>> {
let path = "/contactlabels".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update Contact Label
///
/// `PUT /contactlabels/{id}`
///
/// Replaces an email contact label. Requires "edit masterdata" permission in `churchdb`. Existing email-address associations retain the label ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-contactlabels-id");
/// let body = models::ContactLabelUpdate {
/// is_default: false,
/// name: "Private".into(),
/// sort_key: 10,
/// ..Default::default()
/// };
/// let result = client.contact_labels().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::ContactLabelUpdate) -> Result<models::ContactLabel> {
let path = format!("/contactlabels/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.csrf_token()`
#[derive(Clone, Copy)]
pub struct CsrfTokenResource<'a> {
client: &'a Client,
}
impl<'a> CsrfTokenResource<'a> {
/// CSRF token for the current user
///
/// `GET /csrftoken`
///
/// Returns the CSRF-Token for the current user in the current session. If the session does not exist, null is returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-csrftoken");
/// let result = client.csrf_token().get()?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get(&self) -> Result<Option<String>> {
let path = "/csrftoken".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.db_field_types()`
#[derive(Clone, Copy)]
pub struct DbFieldTypesResource<'a> {
client: &'a Client,
}
impl<'a> DbFieldTypesResource<'a> {
/// Get available field types
///
/// `GET /dbfieldtypes`
///
/// Returns registered database-field types, ordered by sortKey and then name. These types describe the value and input behavior of configurable fields. Names are returned as stored and can be translation keys.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-dbfieldtypes");
/// for db_field_type in client.db_field_types().list()? {
/// println!("{}", db_field_type.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::DbFieldType>> {
let path = "/dbfieldtypes".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.db_fields()`
#[derive(Clone, Copy)]
pub struct DbFieldsResource<'a> {
client: &'a Client,
}
impl<'a> DbFieldsResource<'a> {
pub fn options(&self) -> DbFieldsOptionsResource<'a> {
DbFieldsOptionsResource { client: self.client }
}
/// Create a database field
///
/// `POST /dbfields`
///
/// Creates an installation-specific field definition and database column. Selection types also create an option table with one initial choice. Checkbox fields are non-nullable and cannot be cleared on archive.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::DbFieldCreate {
/// delete_on_archive: true,
/// is_active: true,
/// is_new_person_field: true,
/// name: "Dietary notes".into(),
/// security_level: 1,
/// sort_key: 50,
/// use_as_placeholder: false,
/// field_category_intern_code: "f_address".into(),
/// ..Default::default()
/// };
/// let result = client.db_fields().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::DbFieldCreate) -> Result<models::DbField> {
let path = "/dbfields".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a database field
///
/// `DELETE /dbfields/{fieldId}`
///
/// Deletes a field definition, its physical database column and all values stored in that column; also removes its group-person-field mappings and custom selection table if present. Protected built-in fields cause a conflict.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.db_fields().delete(200)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, field_id: impl Display) -> Result<()> {
let path = format!("/dbfields/{}", seg(field_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a database-field definition
///
/// `GET /dbfields/{fieldId}`
///
/// Returns one database-field definition, including its type, category and API key.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-dbfields-fieldId");
/// let db_field = client.db_fields().get(200)?;
/// println!("{}", db_field.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, field_id: impl Display) -> Result<models::DbField> {
let path = format!("/dbfields/{}", seg(field_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List database-field definitions
///
/// `GET /dbfields`
///
/// Lists built-in and custom field definitions, not the values stored on individual persons or groups. Use `categories[]` to restrict the result and `include[]=options` to expand available choices.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-dbfields");
/// for db_field in client.db_fields().list()? {
/// println!("{}", db_field.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::DbField>> {
self.list_with(&Default::default())
}
/// List database-field definitions
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /dbfields`
///
/// Lists built-in and custom field definitions, not the values stored on individual persons or groups. Use `categories[]` to restrict the result and `include[]=options` to expand available choices.
pub fn list_with(&self, query: &GetDbfieldsQuery) -> Result<Vec<models::DbField>> {
let path = "/dbfields".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a database field
///
/// `PUT /dbfields/{fieldId}`
///
/// Updates a database-field definition. The existing field determines its type. Installation-created person fields can move between `f_address`, `f_church`, `f_category` and `f_datasecurity`.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::DbFieldUpdate {
/// delete_on_archive: true,
/// is_new_person_field: true,
/// security_level: 1,
/// sort_key: 50,
/// use_as_placeholder: false,
/// ..Default::default()
/// };
/// let result = client.db_fields().update(200, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, field_id: impl Display, body: &models::DbFieldUpdate) -> Result<models::DbField> {
let path = format!("/dbfields/{}", seg(field_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.db_fields().options()`
#[derive(Clone, Copy)]
pub struct DbFieldsOptionsResource<'a> {
client: &'a Client,
}
impl<'a> DbFieldsOptionsResource<'a> {
/// Create a database-field option
///
/// `POST /dbfields/{fieldId}/options`
///
/// Creates an option in the selected field’s backing table. Use the metadata endpoint to determine the complete request shape. Fields without a backing table do not support this operation.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::DbFieldOptionCreate {
/// name: Some("Vegetarian".into()),
/// ..Default::default()
/// };
/// let result = client.db_fields().options().create(200, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, field_id: impl Display, body: &models::DbFieldOptionCreate) -> Result<models::DbFieldOption> {
let path = format!("/dbfields/{}/options", seg(field_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a database-field option
///
/// `DELETE /dbfields/{fieldId}/options/{optionId}`
///
/// Deletes an option row from the selected field’s backing masterdata table through the shared deletion service. References can block deletion. `dryRun=true` returns the deletion preview with HTTP 409 without removing the row.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.db_fields().options().delete(200, 3)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, field_id: impl Display, option_id: impl Display) -> Result<()> {
self.delete_with(field_id, option_id, &Default::default())
}
/// Delete a database-field option
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /dbfields/{fieldId}/options/{optionId}`
///
/// Deletes an option row from the selected field’s backing masterdata table through the shared deletion service. References can block deletion. `dryRun=true` returns the deletion preview with HTTP 409 without removing the row.
pub fn delete_with(&self, field_id: impl Display, option_id: impl Display, query: &DeleteDbfieldsFieldIdOptionsOptionIdQuery) -> Result<()> {
let path = format!("/dbfields/{}/options/{}", seg(field_id), seg(option_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// List options for a database field
///
/// `GET /dbfields/{fieldId}/options`
///
/// Lists option rows from the field’s backing masterdata table. Rows are ordered by `sortKey` when available. Fields without a backing table return an empty list. Read the option metadata to interpret row keys.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-dbfields-fieldId-options");
/// for option in client.db_fields().options().list(200)? {
/// println!("{:?}", option.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, field_id: impl Display) -> Result<Vec<models::DbFieldOption>> {
let path = format!("/dbfields/{}/options", seg(field_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get metadata for field options
///
/// `GET /dbfields/{fieldId}/options/metadata`
///
/// Describes the actual SQL columns of the selected field’s backing option table as API properties. Audit columns are omitted. Use this operation only for fields backed by a table.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// for metadata in client.db_fields().options().list_metadata(200)? {
/// println!("{}", metadata.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_metadata(&self, field_id: impl Display) -> Result<Vec<models::DbFieldOptionColumn>> {
let path = format!("/dbfields/{}/options/metadata", seg(field_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a database-field option
///
/// `PUT /dbfields/{fieldId}/options/{optionId}`
///
/// Updates an option row using all non-auto-increment columns from the metadata endpoint. This operation replaces the complete metadata-defined row and supports only fields backed by a table.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::DbFieldOptionUpdate {
/// name: Some("Vegetarian".into()),
/// ..Default::default()
/// };
/// let result = client.db_fields().options().update(200, 3, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, field_id: impl Display, option_id: impl Display, body: &models::DbFieldOptionUpdate) -> Result<models::DbFieldOption> {
let path = format!("/dbfields/{}/options/{}", seg(field_id), seg(option_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.departments()`
#[derive(Clone, Copy)]
pub struct DepartmentsResource<'a> {
client: &'a Client,
}
impl<'a> DepartmentsResource<'a> {
/// Get all departments
///
/// `GET /departments`
///
/// Returns all department definitions, ordered by `sortKey` and then `name`. The caller must be allowed to view `departmentIds` on their current person record. This is a definition list, not a list of persons visible through those departments.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-departments");
/// for department in client.departments().list()? {
/// println!("{}", department.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Department>> {
let path = "/departments".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.domain_objects()`
#[derive(Clone, Copy)]
pub struct DomainObjectsResource<'a> {
client: &'a Client,
}
impl<'a> DomainObjectsResource<'a> {
/// Get domain objects
///
/// `GET /domainobjects`
///
/// Resolves heterogeneous ChurchTools references into compact display objects. Pair `domain_types[]` and `domain_identifiers[]` by index. Output order and count may differ from the input, and repeated IDs may not produce repeated results. Missing or inaccessible objects are usually omitted, but an unresolved `appointment_occurrence` may fail the request. Resolver permissions differ by domain type.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-domainobjects");
/// let query = GetDomainobjectsQuery {
/// domain_types: Some(vec!["person".into(), "group".into()]),
/// domain_identifiers: Some(vec!["42".into(), "7".into()]),
/// ..Default::default()
/// };
/// for domain_object in client.domain_objects().list(&query)? {
/// println!("{:?}", domain_object.api_url);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetDomainobjectsQuery) -> Result<Vec<models::ResolvedDomainObject>> {
let path = "/domainobjects".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Resolve domain objects from a JSON payload
///
/// `POST /domainobjects`
///
/// Read-only JSON alternative to `GET /domainobjects` with the same resolution and permission behavior. Output order and count may differ from the input. Missing or inaccessible objects are usually omitted, but an unresolved `appointment_occurrence` may fail the request.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-domainobjects");
/// let body = models::DomainObjectPayload {
/// domain_identifiers: vec!["42".into(), "7".into()],
/// domain_types: vec!["person".into(), "group".into()],
/// ..Default::default()
/// };
/// for domain_object in client.domain_objects().resolve(&body)? {
/// println!("{:?}", domain_object.api_url);
/// }
/// # Ok(())
/// # }
/// ```
pub fn resolve(&self, body: &models::DomainObjectPayload) -> Result<Vec<models::ResolvedDomainObject>> {
let path = "/domainobjects".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.dynamic_groups()`
#[derive(Clone, Copy)]
pub struct DynamicGroupsResource<'a> {
client: &'a Client,
}
impl<'a> DynamicGroupsResource<'a> {
/// Remove automatic membership rules
///
/// `DELETE /dynamicgroups/{groupId}/ruleset`
///
/// Clears the stored rule set and resets the stored dynamicGroupStatus to null (reported as none by GET /status). Requires churchcore administer persons. Existing group memberships and the group itself remain in place. No refresh is run. The current implementation returns HTTP 200 with an empty body, including when no rule set was stored.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.dynamic_groups().delete_ruleset(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_ruleset(&self, group_id: impl Display) -> Result<()> {
let path = format!("/dynamicgroups/{}/ruleset", seg(group_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get the dynamic membership refresh mode
///
/// `GET /dynamicgroups/{groupId}/status`
///
/// Returns the stored refresh mode of an ordinary group. A missing/null stored status is returned as none. This is configuration, not the progress of an in-flight job or proof that the rules are valid. Requires churchcore administer persons. The response is a flat object without a data wrapper.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-dynamicgroups-id-status");
/// let statu = client.dynamic_groups().get_status(42)?;
/// println!("{}", statu.dynamic_group_status);
/// # Ok(())
/// # }
/// ```
pub fn get_status(&self, group_id: impl Display) -> Result<models::DynamicGroupStatusUpdate> {
let path = format!("/dynamicgroups/{}/status", seg(group_id));
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
/// List groups with automatic membership refresh
///
/// `GET /dynamicgroups`
///
/// Returns IDs of groups whose dynamicGroupStatus is active. A dynamic group is an ordinary ChurchTools group whose memberships can be maintained by a set of query rules. Groups in manual, inactive or none status are excluded, even when a rule set is stored. Conversely, active groups without a valid rule set are included and may fail during refresh. Requires churchcore administer persons. Results are not paginated and no ordering is guaranteed. This preliminary API may change.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-dynamicgroups");
/// for dynamic_group in client.dynamic_groups().list()? {
/// println!("{:?}", dynamic_group);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<i64>> {
let path = "/dynamicgroups".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get stored automatic membership rules
///
/// `GET /dynamicgroups/{groupId}/ruleset`
///
/// Returns the stored rule array directly, without a data wrapper. Requires churchcore administer persons. Rules can exist independently of the refresh status. If the group has no rules, including after an empty array was saved, this returns 404. Reading rules does not execute or validate their query results.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-dynamicgroups-id-ruleset");
/// for ruleset in client.dynamic_groups().list_ruleset(42)? {
/// println!("{}", ruleset.description);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_ruleset(&self, group_id: impl Display) -> Result<Vec<models::DynamicGroupRule>> {
let path = format!("/dynamicgroups/{}/ruleset", seg(group_id));
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
/// Refresh memberships of one dynamic group
///
/// `POST /dynamicgroups/{groupId}/refresh`
///
/// Synchronously evaluates and applies the stored rules of one group. Requires churchcore administer persons and dynamicGroupStatus active or manual. inactive and none reject manual refreshes. The request has no body and no dry-run option. Rules run against the initial membership snapshot and changes are applied as the system user, with at most 500 actual changes per run. Inspect unprocessed and runsNeeded before assuming convergence. A caught processing failure returns 400 with a message; it does not return a successful statistics object. Membership updates have their own transaction, but later timestamp/event/logging failures can occur after those changes have committed.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// for dynamic_group in client.dynamic_groups().refresh(42)? {
/// println!("{}", dynamic_group.created);
/// }
/// # Ok(())
/// # }
/// ```
pub fn refresh(&self, group_id: impl Display) -> Result<Vec<models::DynamicGroupRefreshResult>> {
let path = format!("/dynamicgroups/{}/refresh", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Refresh all active dynamic groups
///
/// `POST /dynamicgroups/refresh`
///
/// Synchronously evaluates and applies membership rules for all groups with active dynamicGroupStatus. Requires churchcore administer persons. Manual, inactive and none groups are excluded. Rules run in ascending importance order against the starting membership snapshot; later field updates can override earlier ones, while any deletion action takes precedence. Membership writes run as the system user and can bypass the group size limit. Each group is processed separately; this is not a transaction across groups. At most 500 actual changes are applied per group per run, so inspect unprocessed and runsNeeded and repeat if necessary. A 200 response can contain per-group failures alongside successful statistics. Error entries lack a structured groupId; unexpected Errors can still abort the whole request. This endpoint performs changes immediately and does not support a dry run.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// for dynamic_group in client.dynamic_groups().refresh_all()? {
/// println!("{:?}", dynamic_group);
/// }
/// # Ok(())
/// # }
/// ```
pub fn refresh_all(&self) -> Result<Vec<serde_json::Value>> {
let path = "/dynamicgroups/refresh".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Replace automatic membership rules
///
/// `PUT /dynamicgroups/{groupId}/ruleset`
///
/// Stores the complete rule array after validation against the dynamic-group JSON schema. Requires churchcore administer persons. Rule syntax validation does not execute queries or validate all referenced roles, fields and runtime process values. Saving rules does not change dynamicGroupStatus or immediately update memberships. Use PUT /status to select the refresh mode and POST /refresh to run it explicitly. An empty array stores no rule set and returns dynamicGroupRuleSet: null, even if the group remains active. The response has a dynamicGroupRuleSet property directly, without a data wrapper.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::DynamicGroupRuleSetUpdate {
/// dynamic_group_rule_set: vec![models::DynamicGroupRule {
/// description: "Add selected people to the group.".into(),
/// importance: 10,
/// person_id_field_name: "person.id".into(),
/// process: models::DynamicGroupProcessSets {
/// group_and_query_result: models::DynamicGroupProcessSetsGroupAndQueryResult::default(),
/// group_only: models::DynamicGroupProcessSetsGroupOnly::default(),
/// query_result_only: models::DynamicGroupProcessSetsQueryResultOnly::default(),
/// ..Default::default()
/// },
/// query: models::DynamicGroupQuery {
/// method: "ChurchQuery".into(),
/// params: models::DynamicGroupQueryParams::default(),
/// ..Default::default()
/// },
/// shorty: "selected-people".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.dynamic_groups().update_ruleset(42, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update_ruleset(&self, group_id: impl Display, body: &models::DynamicGroupRuleSetUpdate) -> Result<models::PutDynamicgroupsIdRulesetResponse> {
let path = format!("/dynamicgroups/{}/ruleset", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Put, &path, &query, Some(&body))
}
/// Set the dynamic membership refresh mode
///
/// `PUT /dynamicgroups/{groupId}/status`
///
/// Sets active, manual, inactive or none for an existing group. Requires churchcore administer persons. This does not run a refresh, delete stored rules or alter existing memberships. The mode is not checked against the presence or validity of a rule set, so an active group can subsequently fail to refresh. To remove rules as well, use DELETE /ruleset. The response is a flat object without a data wrapper.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::DynamicGroupStatusUpdate {
/// dynamic_group_status: "manual".into(),
/// ..Default::default()
/// };
/// let result = client.dynamic_groups().update_status(42, &body)?;
/// println!("{}", result.dynamic_group_status);
/// # Ok(())
/// # }
/// ```
pub fn update_status(&self, group_id: impl Display, body: &models::DynamicGroupStatusUpdate) -> Result<models::DynamicGroupStatusUpdate> {
let path = format!("/dynamicgroups/{}/status", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Put, &path, &query, Some(&body))
}
}
/// `client.emails()`
#[derive(Clone, Copy)]
pub struct EmailsResource<'a> {
client: &'a Client,
}
impl<'a> EmailsResource<'a> {
/// Get email placeholder statistics
///
/// `POST /emails/placeholderstatistics`
///
/// Renders placeholder statistics for the visible subset of personIds without sending emails. Content fragments are concatenated, optionally inserted into an accessible HTML template, then evaluated for each person. Missing/inaccessible recipients are omitted; if none are visible, the request returns 404. Without placeholder-like syntax in the resulting text, data is empty even when recipients were supplied. Results follow the loaded recipient order, not necessarily the input order; correlate by personId. Stats report availability of evaluated placeholders, not their values or occurrence counts. A subject is not part of this request. The automaticEmailId parameter currently has no effect.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EmailPlaceholderStatisticsCreate {
/// content: vec!["Hello {{person.firstName}}".into()],
/// person_ids: vec![1, 2],
/// ..Default::default()
/// };
/// for email in client.emails().placeholder_statistics(&body)? {
/// println!("{}", email.person_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn placeholder_statistics(&self, body: &models::EmailPlaceholderStatisticsCreate) -> Result<Vec<models::EmailPlaceholderStatistics>> {
let path = "/emails/placeholderstatistics".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Render an email preview
///
/// `POST /emails/preview`
///
/// Renders content and an optional subject for one person visible to the caller. No email is sent and no draft is saved. Content fragments are concatenated without separators; an optional template replaces its {{body}} tokens before placeholder expansion. groupId adds group and membership context and requires access to that group. The HTML template requires template-view permission, or permission to view automatic emails for the supplied group. Missing or inaccessible recipients return 404. The flat response always contains html and contains subject only when supplied. userId selects a placeholder acting context rather than a recipient and is handled differently by individual decorators; it is not an authenticated-user switch for the whole request.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-emails-preview");
/// let body = models::EmailPreviewCreate {
/// content: vec!["Hello {{person.firstName}}".into()],
/// person_id: 1,
/// ..Default::default()
/// };
/// let email = client.emails().preview(&body)?;
/// println!("{}", email.html);
/// # Ok(())
/// # }
/// ```
pub fn preview(&self, body: &models::EmailPreviewCreate) -> Result<models::EmailPreview> {
let path = "/emails/preview".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
}
/// `client.evangelische_termine()`
#[derive(Clone, Copy)]
pub struct EvangelischeTermineResource<'a> {
client: &'a Client,
}
impl<'a> EvangelischeTermineResource<'a> {
/// Queue deletion of published external appointments
///
/// `DELETE /evangelischetermine`
///
/// Queues removal of ChurchTools-published appointments from the configured Evangelische Termine organizer. Local ChurchTools appointments are retained. The background job reads the external JSON event list and deletes remote dates whose external identifier starts with ChurchTools; it does not limit removal to calendars currently selected for synchronization. Requires the churchcore permission "administer settings". HTTP 204 means the deletion job was queued and started in the background, not that remote deletion has completed. If synchronization is disabled, this call returns 204 without queuing a job. It does not disable synchronization, so later synchronization can publish appointments again. There is no dry-run option or returned job identifier.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.evangelische_termine().delete()?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self) -> Result<()> {
let path = "/evangelischetermine".to_owned();
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get external event classifications
///
/// `GET /evangelischetermine/eventtypes`
///
/// Fetches the eventtype parameter values from the configured Evangelische Termine SOAP service. Use the returned keys and labels when selecting an external event classification. ChurchTools forwards the external list without adding pagination or meta. Synchronization must already be enabled and its stored connection settings must work. The controller has no additional settings-administration permission check beyond API authentication.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// for event_type in client.evangelische_termine().list_event_types()? {
/// println!("{}", event_type.key);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_event_types(&self) -> Result<Vec<models::EvangelischeTermineEventType>> {
let path = "/evangelischetermine/eventtypes".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Test external synchronization settings
///
/// `POST /evangelischetermine/validatesettings`
///
/// Tests the supplied server URL, organizer ID and API key by creating a SOAP connection and requesting the external event types. Requires the churchcore permission "administer settings". The integration need not already be enabled. A successful test returns 200 with an empty body; it does not save the settings, enable synchronization or publish appointments. A rejected URL or failed connection/authentication check returns 400 with an empty body. Invalid request-field types can instead return a JSON validation error.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EvangelischeTermineSettingsValidateCreate {
/// api_key: "*****".into(),
/// url: "https://www.evangelische-termine.de".into(),
/// vid: "1234".into(),
/// ..Default::default()
/// };
/// client.evangelische_termine().validate_settings(&body)?;
/// # Ok(())
/// # }
/// ```
pub fn validate_settings(&self, body: &models::EvangelischeTermineSettingsValidateCreate) -> Result<()> {
let path = "/evangelischetermine/validatesettings".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.event()`
#[derive(Clone, Copy)]
pub struct EventResource<'a> {
client: &'a Client,
}
impl<'a> EventResource<'a> {
/// Get Event module reference data
///
/// `GET /event/masterdata`
///
/// Returns six complete reference-data lists for the Event module together with their individual counts in `meta`. All lists are present and unpaginated; receiving a record does not grant permission to use or edit it. Song categories and sources have no guaranteed list order.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-event-masterdata");
/// let master_data = client.event().get_master_data()?;
/// println!("{:?}", master_data);
/// # Ok(())
/// # }
/// ```
pub fn get_master_data(&self) -> Result<models::EventMasterData> {
let path = "/event/masterdata".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.event_templates()`
#[derive(Clone, Copy)]
pub struct EventTemplatesResource<'a> {
client: &'a Client,
}
impl<'a> EventTemplatesResource<'a> {
/// Get all event templates
///
/// `GET /eventtemplates`
///
/// Returns all event templates as an unpaginated list, sorted by `sortKey` ascending. No per-template visibility filter is applied.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-eventtemplates");
/// for event_template in client.event_templates().list()? {
/// println!("{}", event_template.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::EventTemplate>> {
let path = "/eventtemplates".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.events()`
#[derive(Clone, Copy)]
pub struct EventsResource<'a> {
client: &'a Client,
}
impl<'a> EventsResource<'a> {
pub fn agenda(&self) -> EventsAgendaResource<'a> {
EventsAgendaResource { client: self.client }
}
pub fn event_services(&self) -> EventsEventServicesResource<'a> {
EventsEventServicesResource { client: self.client }
}
pub fn facts(&self) -> EventsFactsResource<'a> {
EventsFactsResource { client: self.client }
}
pub fn service_requests(&self) -> EventsServiceRequestsResource<'a> {
EventsServiceRequestsResource { client: self.client }
}
pub fn services(&self) -> EventsServicesResource<'a> {
EventsServicesResource { client: self.client }
}
/// Start or stop an event chat
///
/// `POST /events/{eventId}/chat`
///
/// Starts, reactivates or stops the chat linked to this event. Requires access to the event, an active chat installation with event chats enabled, and permission to administer persons, start an event chat through event permissions, or administer this event. A new room is provisioned through the chat service; HTTP `200` does not guarantee that remote room setup is already complete. Stopping a chat that has never been created returns `404`.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EventChatUpdate {
/// enabled: true,
/// ..Default::default()
/// };
/// client.events().chat(42, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn chat(&self, event_id: impl Display, body: &models::EventChatUpdate) -> Result<()> {
let path = format!("/events/{}/chat", seg(event_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Create iCal roster link
///
/// `POST /events/ical`
///
/// Creates a new personal roster subscription secret and returns the link as JSON. Use `meta.iCalUrl` to fetch the actual iCalendar feed. A roster contains the person's service assignments at events, including pending requests and confirmed assignments.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = PostEventsIcalQuery {
/// person_id: Some(42),
/// ..Default::default()
/// };
/// let result = client.events().create_ical(&query)?;
/// println!("{}", result.attribute);
/// # Ok(())
/// # }
/// ```
pub fn create_ical(&self, query: &PostEventsIcalQuery) -> Result<models::RosterICalSetting> {
let path = "/events/ical".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Delete a single event
///
/// `DELETE /events/{eventId}`
///
/// Deletes the service-planning event through the dependency-aware deletion service. With `dryRun`=`true`, the deletion check returns a `409` report without deleting the event, but `sendMail` is processed before that check. Requires event administration access, the "edit events" permission for the event calendar, or a corresponding internal group permission.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.events().delete(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, event_id: impl Display) -> Result<()> {
self.delete_with(event_id, &Default::default())
}
/// Delete a single event
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /events/{eventId}`
///
/// Deletes the service-planning event through the dependency-aware deletion service. With `dryRun`=`true`, the deletion check returns a `409` report without deleting the event, but `sendMail` is processed before that check. Requires event administration access, the "edit events" permission for the event calendar, or a corresponding internal group permission.
pub fn delete_with(&self, event_id: impl Display, query: &DeleteEventsIdQuery) -> Result<()> {
let path = format!("/events/{}", seg(event_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a single event
///
/// `GET /events/{eventId}`
///
/// Returns the event visible to the current user, including calendar, eventFiles and eventServices. Service assignments are filtered by service-group visibility or own assignment; persons can be concealed. The eventServices property is present even when empty. Cancelled events can also be read if visible.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events-id");
/// let event = client.events().get(42)?;
/// println!("{}", event.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, event_id: impl Display) -> Result<models::EventReadWithServices> {
let path = format!("/events/{}", seg(event_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get iCal roster link
///
/// `GET /events/ical`
///
/// Returns the personal roster subscription as JSON. If no secret exists, this `GET` creates one; otherwise it preserves the existing link. Use `meta.iCalUrl` to fetch the actual iCalendar feed. A roster contains the person's service assignments at events, including pending requests and confirmed assignments.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events-ical");
/// let query = GetEventsIcalQuery {
/// person_id: Some(42),
/// ..Default::default()
/// };
/// let ical = client.events().get_ical(&query)?;
/// println!("{}", ical.attribute);
/// # Ok(())
/// # }
/// ```
pub fn get_ical(&self, query: &GetEventsIcalQuery) -> Result<models::RosterICalSetting> {
let path = "/events/ical".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all events
///
/// `GET /events`
///
/// Returns events visible through calendar permissions or the current user’s valid service assignments. Date comparisons use midnight in the application time zone: to includes exactly midnight, not later events that day. Results from calendar access are merged with events where the user is assigned and deduplicated; this merged range list is not guaranteed to be globally sorted. With direction, selects one page relative to from and ignores to.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events");
/// for event in client.events().list()? {
/// println!("{}", event.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Event>> {
self.list_with(&Default::default())
}
/// Get all events
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /events`
///
/// Returns events visible through calendar permissions or the current user’s valid service assignments. Date comparisons use midnight in the application time zone: to includes exactly midnight, not later events that day. Results from calendar access are merged with events where the user is assigned and deduplicated; this merged range list is not guaranteed to be globally sorted. With direction, selects one page relative to from and ignores to.
pub fn list_with(&self, query: &GetEventsQuery) -> Result<Vec<models::Event>> {
let path = "/events".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all events
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetEventsQuery) -> Items<models::Event> {
let path = "/events".to_owned();
self.client.items(&path, query.to_query())
}
/// Get all possible persons for a service
///
/// `GET /events/{serviceId}/possiblepersonsforservice`
///
/// Returns an unpaginated, deduplicated list of persons from active, non-hidden memberships in groups connected to the service. If connected tags exist, a matching tag is also required. Archived or deceased persons are excluded and hidden-person visibility is respected. With no connected groups, the result is empty.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events-id-possiblepersonsforservice");
/// for possible_persons_for_service in client.events().list_possible_persons_for_service(2)? {
/// println!("{}", possible_persons_for_service.full_name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_possible_persons_for_service(&self, service_id: impl Display) -> Result<Vec<models::ServiceCandidate>> {
let path = format!("/events/{}/possiblepersonsforservice", seg(service_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Send an email to selected event recipients
///
/// `POST /events/send`
///
/// Sends an email to selected people in the context of one or more events. ChurchTools filters service participants by visible service groups and other selected recipients by person visibility. The response reports effective and rejected recipients. `sendCopyToMe` can add the sender. Optional agenda buttons require agenda visibility for each event; sending does not require an agenda or a shared agenda across events.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EventMailCreate {
/// body: "<p>Please review the updated agenda for Sunday.</p>".into(),
/// event_ids: vec![31, 32],
/// recipients: vec![40, 41],
/// subject: "Updated Sunday agenda".into(),
/// append_agenda_button: true,
/// files: vec![42],
/// ..Default::default()
/// };
/// let event = client.events().send(&body)?;
/// println!("{:?}", event);
/// # Ok(())
/// # }
/// ```
pub fn send(&self, body: &models::EventMailCreate) -> Result<models::EventMailSendResult> {
let path = "/events/send".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Update event details
///
/// `PUT /events/{eventId}`
///
/// Updates the description, administrators and cancellation state for this service-planning event. It does not update service assignments or the calendar appointment. Changing the administrator set additionally requires the "edit masterdata" permission for the service planning domain; other changes require event administration access, the "edit events" permission for the event calendar, or a corresponding internal group permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EventDetailsUpdate {
/// description: Some(Some("Sound check starts 30 minutes before the gathering.".into())),
/// ..Default::default()
/// };
/// let result = client.events().update(42, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, event_id: impl Display, body: &models::EventDetailsUpdate) -> Result<models::EventDetailsUpdateResult> {
let path = format!("/events/{}", seg(event_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.events().agenda()`
#[derive(Clone, Copy)]
pub struct EventsAgendaResource<'a> {
client: &'a Client,
}
impl<'a> EventsAgendaResource<'a> {
pub fn items(&self) -> EventsAgendaItemsResource<'a> {
EventsAgendaItemsResource { client: self.client }
}
/// Detach the agenda from an event
///
/// `DELETE /events/{eventId}/agenda`
///
/// Removes only the link between the event and its agenda. Other events sharing this agenda retain their links and content. If no event links remain, the unused agenda is cleaned up later. A locked agenda can also be detached. Requires agenda editing access for the event.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.events().agenda().delete(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, event_id: impl Display) -> Result<()> {
let path = format!("/events/{}/agenda", seg(event_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Export event agenda
///
/// `POST /events/{eventId}/agenda/export`
///
/// Generates a presenter import archive for an event agenda. Requires a super administrator, an event administrator, "view agenda" or "edit agenda" for the event calendar, or involvement in the event. The current exporters use all items from the shared agenda, including items hidden for the requested event; the archive is not filtered to that event's visible positions. Locked and unlocked agendas can be exported.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = PostEventsIdAgendaExportQuery {
/// format: Some("SONG_BEAMER".into()),
/// ..Default::default()
/// };
/// let body = models::AgendaExportCreate {
/// append_arrangement: true,
/// export_songs: true,
/// with_category: false,
/// ..Default::default()
/// };
/// let agenda = client.events().agenda().export(42, &query, &body)?;
/// println!("{}", agenda.url);
/// # Ok(())
/// # }
/// ```
pub fn export(&self, event_id: impl Display, query: &PostEventsIdAgendaExportQuery, body: &models::AgendaExportCreate) -> Result<models::AgendaExport> {
let path = format!("/events/{}/agenda/export", seg(event_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get agenda for event
///
/// `GET /events/{eventId}/agenda`
///
/// Returns the event's running plan, including all ordered items, shared lock state and calculated times for linked events. Header, text and song items use different response fields; hidden items remain in `items` with a `null` entry in `startTimes`. Responsibility placeholders are resolved for the requested event and service-group notes are visibility-filtered.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events-id-agenda");
/// let agenda = client.events().agenda().get(42)?;
/// println!("{:?}", agenda.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, event_id: impl Display) -> Result<models::Agenda> {
let path = format!("/events/{}/agenda", seg(event_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Integrate agenda with another event
///
/// `POST /events/{eventId}/agenda/integrate`
///
/// Links the target event in the path to the existing agenda of the source event given by `event_id`. This creates a shared agenda, not a copy: item IDs, content and lock state are shared with all already linked events. Event dates remain independent and item times are calculated per event. Hidden-item settings of the source event are not copied to the new link. Requires agenda editing permission for the target and agenda viewing permission for the source.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = PostEventsIdAgendaIntegrateQuery {
/// event_id: Some(1337),
/// ..Default::default()
/// };
/// let agenda = client.events().agenda().integrate(42, &query)?;
/// println!("{:?}", agenda.name);
/// # Ok(())
/// # }
/// ```
pub fn integrate(&self, event_id: impl Display, query: &PostEventsIdAgendaIntegrateQuery) -> Result<models::Agenda> {
let path = format!("/events/{}/agenda/integrate", seg(event_id));
let query: Query = query.to_query();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Get songs referenced by an agenda
///
/// `GET /events/{eventId}/agenda/songs`
///
/// Returns the distinct songs referenced by song items with an assigned arrangement in the event's agenda. Includes songs from positions hidden for this event because the complete shared agenda is inspected. Multiple positions or arrangements referring to one song produce one song record. Each record includes all arrangements of that song, not only the arrangement selected in the agenda.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events-id-agenda-songs");
/// for song in client.events().agenda().list_songs(42)? {
/// println!("{}", song.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_songs(&self, event_id: impl Display) -> Result<Vec<models::Song>> {
let path = format!("/events/{}/agenda/songs", seg(event_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Lock a shared agenda
///
/// `POST /events/{eventId}/agenda/lock`
///
/// Locks the event's agenda against content changes. Events integrated with this event share the same agenda and therefore the same lock state. This is an agenda state, not a temporary editing lock owned by the caller. Calling lock on an already locked agenda returns `403`. Requires agenda editing access for the event.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.events().agenda().lock(42)?;
/// # Ok(())
/// # }
/// ```
pub fn lock(&self, event_id: impl Display) -> Result<()> {
let path = format!("/events/{}/agenda/lock", seg(event_id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Unlock a shared agenda
///
/// `POST /events/{eventId}/agenda/unlock`
///
/// Unlocks the event's agenda so its content can be edited again. The change applies to all events sharing the agenda. Calling unlock on an already unlocked agenda returns `403`. Any caller with the required agenda editing permission can unlock it; the caller need not be the person who locked it. Requires agenda editing access for the event.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.events().agenda().unlock(42)?;
/// # Ok(())
/// # }
/// ```
pub fn unlock(&self, event_id: impl Display) -> Result<()> {
let path = format!("/events/{}/agenda/unlock", seg(event_id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Create or update agenda
///
/// `PUT /events/{eventId}/agenda`
///
/// Creates an agenda for an event that has none, or updates its existing agenda. The operation always returns `200`. Supply `calendarId` when creating without a copy source. On update, the agenda must be unlocked; changes to a shared agenda affect every linked event. Requires agenda editing permission for the target and viewing permission for a selected source agenda or template.
///
/// Use [`Self::update_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = serde_json::json!({});
/// let result = client.events().agenda().update(42, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, event_id: impl Display, body: &serde_json::Value) -> Result<models::Agenda> {
self.update_with(event_id, &Default::default(), body)
}
/// Create or update agenda
///
/// Like [`Self::update`], with query parameters.
///
/// `PUT /events/{eventId}/agenda`
///
/// Creates an agenda for an event that has none, or updates its existing agenda. The operation always returns `200`. Supply `calendarId` when creating without a copy source. On update, the agenda must be unlocked; changes to a shared agenda affect every linked event. Requires agenda editing permission for the target and viewing permission for a selected source agenda or template.
pub fn update_with(&self, event_id: impl Display, query: &PutEventsIdAgendaQuery, body: &serde_json::Value) -> Result<models::Agenda> {
let path = format!("/events/{}/agenda", seg(event_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.events().agenda().items()`
#[derive(Clone, Copy)]
pub struct EventsAgendaItemsResource<'a> {
client: &'a Client,
}
impl<'a> EventsAgendaItemsResource<'a> {
pub fn service_groups(&self) -> EventsAgendaItemsServiceGroupsResource<'a> {
EventsAgendaItemsServiceGroupsResource { client: self.client }
}
/// Create agenda item
///
/// `POST /events/{eventId}/agenda/items`
///
/// Creates one header, text or song item in an existing, unlocked agenda. Without `before_id` or `after_id`, the item is appended. The agenda is not created automatically. Positioning references must belong to the same agenda. Requires agenda editing access for the event.
///
/// Use [`Self::create_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-events-id-agenda-items");
/// let body = serde_json::json!({
/// "type": "header"
/// });
/// let result = client.events().agenda().items().create(42, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, event_id: impl Display, body: &serde_json::Value) -> Result<serde_json::Value> {
self.create_with(event_id, &Default::default(), body)
}
/// Create agenda item
///
/// Like [`Self::create`], with query parameters.
///
/// `POST /events/{eventId}/agenda/items`
///
/// Creates one header, text or song item in an existing, unlocked agenda. Without `before_id` or `after_id`, the item is appended. The agenda is not created automatically. Positioning references must belong to the same agenda. Requires agenda editing access for the event.
pub fn create_with(&self, event_id: impl Display, query: &PostEventsIdAgendaItemsQuery, body: &serde_json::Value) -> Result<serde_json::Value> {
let path = format!("/events/{}/agenda/items", seg(event_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete an item from a shared agenda
///
/// `DELETE /events/{eventId}/agenda/items/{itemId}`
///
/// Permanently removes an item from the agenda, affecting every event sharing that agenda. The agenda must be unlocked and the item must belong to the event's agenda. Repeating the deletion returns `404` once the item no longer exists. Requires agenda editing access for the event.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.events().agenda().items().delete(42, 123)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, event_id: impl Display, item_id: impl Display) -> Result<()> {
let path = format!("/events/{}/agenda/items/{}", seg(event_id), seg(item_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Hide an agenda item for one event
///
/// `POST /events/{eventId}/agenda/items/{itemId}/hide`
///
/// Omits an agenda item only for the event in the path. The item remains part of the shared agenda and its visibility in other integrated events is unchanged. It no longer contributes to the timing of this event. Agenda responses still contain the item: its `startTimes` entry for this event is `null`. Requires agenda editing access for the event.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.events().agenda().items().hide(42, 123)?;
/// # Ok(())
/// # }
/// ```
pub fn hide(&self, event_id: impl Display, item_id: impl Display) -> Result<()> {
let path = format!("/events/{}/agenda/items/{}/hide", seg(event_id), seg(item_id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Show an agenda item for one event
///
/// `POST /events/{eventId}/agenda/items/{itemId}/unhide`
///
/// Includes a previously hidden item in the event's agenda timing again. This only changes its visibility for the event in the path; other integrated events retain their visibility settings. The agenda must be unlocked and the item must belong to it. Showing an already visible item succeeds with `204`. Requires agenda editing access for the event.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.events().agenda().items().unhide(42, 123)?;
/// # Ok(())
/// # }
/// ```
pub fn unhide(&self, event_id: impl Display, item_id: impl Display) -> Result<()> {
let path = format!("/events/{}/agenda/items/{}/unhide", seg(event_id), seg(item_id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Update agenda item
///
/// `PUT /events/{eventId}/agenda/items/{itemId}`
///
/// Updates one item in an existing, unlocked agenda. The item must belong to the event's agenda. Without `before_id` or `after_id`, its order is preserved. To move an item, send its content fields as well: this is not a position-only PATCH. Requires agenda editing access for the event.
///
/// Use [`Self::update_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-events-id-agenda-items-id");
/// let body = serde_json::json!({
/// "type": "header"
/// });
/// let result = client.events().agenda().items().update(42, 123, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, event_id: impl Display, item_id: impl Display, body: &serde_json::Value) -> Result<serde_json::Value> {
self.update_with(event_id, item_id, &Default::default(), body)
}
/// Update agenda item
///
/// Like [`Self::update`], with query parameters.
///
/// `PUT /events/{eventId}/agenda/items/{itemId}`
///
/// Updates one item in an existing, unlocked agenda. The item must belong to the event's agenda. Without `before_id` or `after_id`, its order is preserved. To move an item, send its content fields as well: this is not a position-only PATCH. Requires agenda editing access for the event.
pub fn update_with(&self, event_id: impl Display, item_id: impl Display, query: &PutEventsIdAgendaItemsIdQuery, body: &serde_json::Value) -> Result<serde_json::Value> {
let path = format!("/events/{}/agenda/items/{}", seg(event_id), seg(item_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.events().agenda().items().service_groups()`
#[derive(Clone, Copy)]
pub struct EventsAgendaItemsServiceGroupsResource<'a> {
client: &'a Client,
}
impl<'a> EventsAgendaItemsServiceGroupsResource<'a> {
/// Delete service group note from agenda item
///
/// `DELETE /events/{eventId}/agenda/items/{itemId}/servicegroups/{serviceGroupId}`
///
/// Removes only the note for the service group in the path. If that note is already absent, the request still succeeds with `204`. Other service-group notes and item content are retained. The agenda must be unlocked and the item must belong to it. Requires agenda editing access for the event.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.events().agenda().items().service_groups().delete(42, 123, 13)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, event_id: impl Display, item_id: impl Display, service_group_id: impl Display) -> Result<()> {
let path = format!("/events/{}/agenda/items/{}/servicegroups/{}", seg(event_id), seg(item_id), seg(service_group_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Add or update service group note for agenda item
///
/// `PUT /events/{eventId}/agenda/items/{itemId}/servicegroups/{serviceGroupId}`
///
/// Creates or replaces the note for one service group on an existing agenda item. Other service-group notes and item content are retained. Requires agenda editing access for the event.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AgendaServiceGroupNoteUpdate {
/// note: Some(Some("Remember to bring the sheet music".into())),
/// ..Default::default()
/// };
/// client.events().agenda().items().service_groups().update(42, 123, 13, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, event_id: impl Display, item_id: impl Display, service_group_id: impl Display, body: &models::AgendaServiceGroupNoteUpdate) -> Result<()> {
let path = format!("/events/{}/agenda/items/{}/servicegroups/{}", seg(event_id), seg(item_id), seg(service_group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.events().event_services()`
#[derive(Clone, Copy)]
pub struct EventsEventServicesResource<'a> {
client: &'a Client,
}
impl<'a> EventsEventServicesResource<'a> {
/// Decline service request
///
/// `DELETE /events/{eventId}/eventservices/{serviceId}`
///
/// Deprecated alias for `/events/{eventId}/servicerequests/{requestId}/decline`. The path parameter `serviceId` identifies a concrete assignment record (`requestId`), not a reusable service role. Declining invalidates the original record and returns a new unassigned record; assigned persons need `allowDecline` unless another permission grants access.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ServiceRequestAnswer {
/// comment: Some(Some("Hallo zusammen".into())),
/// ..Default::default()
/// };
/// let event_service = client.events().event_services().delete(42, 42, &body)?;
/// println!("{:?}", event_service.name);
/// # Ok(())
/// # }
/// ```
#[deprecated = "DELETE /events/{eventId}/eventservices/{serviceId} is deprecated in the ChurchTools API."]
pub fn delete(&self, event_id: impl Display, service_id: impl Display, body: &models::ServiceRequestAnswer) -> Result<models::ServiceRequest> {
let path = format!("/events/{}/eventservices/{}", seg(event_id), seg(service_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Delete, &path, &query, Some(&body))
}
/// Update a service assignment
///
/// `PUT /events/{eventId}/eventservices/{serviceId}`
///
/// Deprecated alias for `/events/{eventId}/servicerequests/{requestId}`. The path parameter `serviceId` identifies a concrete assignment record (`requestId`), not a reusable service role. Creates a replacement assignment and invalidates the previous active record for the same event, service and slot index. Always use the returned ID for subsequent actions.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ServiceRequestUpdate {
/// name: Some(Some("Guest musician".into())),
/// ..Default::default()
/// };
/// let result = client.events().event_services().update(42, 42, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
#[deprecated = "PUT /events/{eventId}/eventservices/{serviceId} is deprecated in the ChurchTools API."]
pub fn update(&self, event_id: impl Display, service_id: impl Display, body: &models::ServiceRequestUpdate) -> Result<models::ServiceRequest> {
let path = format!("/events/{}/eventservices/{}", seg(event_id), seg(service_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
/// Set service slot counts for an event
///
/// `PUT /events/{eventId}/eventservices`
///
/// Changes the active slot count only for the listed service roles, in one transaction. Increasing a count creates unassigned slots. Decreasing it removes unassigned slots but retains occupied slots. A failed reduction returns `422` and rolls back the update; changing counts requires event administration or editing access for every affected service.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EventServicesUpdate {
/// services: vec![models::EventServiceCountUpdate {
/// count: 3,
/// service_id: 2,
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// client.events().event_services().update_all(42, &body)?;
/// # Ok(())
/// # }
/// ```
#[deprecated = "PUT /events/{eventId}/eventservices is deprecated in the ChurchTools API."]
pub fn update_all(&self, event_id: impl Display, body: &models::EventServicesUpdate) -> Result<()> {
let path = format!("/events/{}/eventservices", seg(event_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.events().facts()`
#[derive(Clone, Copy)]
pub struct EventsFactsResource<'a> {
client: &'a Client,
}
impl<'a> EventsFactsResource<'a> {
/// Delete a recorded event fact
///
/// `DELETE /events/{eventId}/facts/{factId}`
///
/// Removes the stored value for this event and fact definition, preserving the reusable definition and the event. Requires access to the event and edit permission for the fact definition. Returns `204` even if no value was stored for the pair.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.events().facts().delete(42, 1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, event_id: impl Display, fact_id: impl Display) -> Result<()> {
let path = format!("/events/{}/facts/{}", seg(event_id), seg(fact_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Export event facts as a spreadsheet
///
/// `POST /events/facts/export`
///
/// Downloads a CSV or XLSX file with one row per visible service-planning event in the selected calendars, including events without recorded fact values. Requires permission to export facts (the "export facts" permission for the service planning domain). Events are filtered by event visibility, and fact columns are limited to definitions the user may view or edit. Rows are ordered by event start time, then event ID.
///
/// Use [`Self::export_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EventFactExportCreate {
/// calendar_ids: vec![42],
/// ..Default::default()
/// };
/// let data = client.events().facts().export(&body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn export(&self, body: &models::EventFactExportCreate) -> Result<Vec<u8>> {
self.export_with(&Default::default(), body)
}
/// Export event facts as a spreadsheet
///
/// Like [`Self::export`], with query parameters.
///
/// `POST /events/facts/export`
///
/// Downloads a CSV or XLSX file with one row per visible service-planning event in the selected calendars, including events without recorded fact values. Requires permission to export facts (the "export facts" permission for the service planning domain). Events are filtered by event visibility, and fact columns are limited to definitions the user may view or edit. Rows are ordered by event start time, then event ID.
pub fn export_with(&self, query: &PostEventsFactsExportQuery, body: &models::EventFactExportCreate) -> Result<Vec<u8>> {
let path = "/events/facts/export".to_owned();
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
/// Get a recorded event fact
///
/// `GET /events/{eventId}/facts/{factId}`
///
/// Returns the stored value for the event and fact definition identified by the path. Requires access to the event and view or edit permission for the fact definition. Returns `404` when no value has been recorded for this pair; this is distinct from a recorded numeric zero.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events-eventId-facts-factId");
/// let fact = client.events().facts().get(42, 1)?;
/// println!("{}", fact.deprecated);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, event_id: impl Display, fact_id: impl Display) -> Result<models::EventFact> {
let path = format!("/events/{}/facts/{}", seg(event_id), seg(fact_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List recorded facts for an event
///
/// `GET /events/{eventId}/facts`
///
/// Returns the event's stored fact values whose definitions the user may view or edit. `eventId` identifies the service-planning event, while `factId` identifies a reusable definition from `/facts`. Requires access to the event and at least one fact definition.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events-eventId-facts");
/// for fact in client.events().facts().list(42)? {
/// println!("{}", fact.deprecated);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, event_id: impl Display) -> Result<Vec<models::EventFact>> {
let path = format!("/events/{}/facts", seg(event_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List recorded event facts
///
/// `GET /events/facts`
///
/// A fact definition describes a metric or selection (for example attendance or service type). An event fact stores one value for that definition on a service-planning event. `eventId` identifies the event, not its calendar appointment; `factId` identifies the reusable definition from /facts. Returns recorded values ordered by event start date descending, with pagination.
///
/// Use [`Self::list_all_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events-facts");
/// for all in client.events().facts().list_all()? {
/// println!("{}", all.deprecated);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_all(&self) -> Result<Vec<models::EventFact>> {
self.list_all_with(&Default::default())
}
/// List recorded event facts
///
/// Like [`Self::list_all`], with query parameters.
///
/// `GET /events/facts`
///
/// A fact definition describes a metric or selection (for example attendance or service type). An event fact stores one value for that definition on a service-planning event. `eventId` identifies the event, not its calendar appointment; `factId` identifies the reusable definition from /facts. Returns recorded values ordered by event start date descending, with pagination.
pub fn list_all_with(&self, query: &GetEventsFactsQuery) -> Result<Vec<models::EventFact>> {
let path = "/events/facts".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List recorded event facts
///
/// Like [`Self::list_all_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_all_iter(&self, query: &GetEventsFactsQuery) -> Items<models::EventFact> {
let path = "/events/facts".to_owned();
self.client.items(&path, query.to_query())
}
/// Create or replace an event fact
///
/// `PUT /events/{eventId}/facts/{factId}`
///
/// Stores one value for the event and fact definition identified by the path. Returns `200` for both insertion and replacement. Requires access to the event and edit permission for the fact definition. Numeric facts accept JSON numbers or numeric strings and return a JSON number; select facts accept an option configured in the definition.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EventFactUpdate {
/// value: serde_json::json!(1.5),
/// ..Default::default()
/// };
/// let result = client.events().facts().update(42, 1, &body)?;
/// println!("{}", result.deprecated);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, event_id: impl Display, fact_id: impl Display, body: &models::EventFactUpdate) -> Result<models::EventFact> {
let path = format!("/events/{}/facts/{}", seg(event_id), seg(fact_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.events().service_requests()`
#[derive(Clone, Copy)]
pub struct EventsServiceRequestsResource<'a> {
client: &'a Client,
}
impl<'a> EventsServiceRequestsResource<'a> {
/// Accept service request
///
/// `POST /events/{eventId}/servicerequests/{requestId}/accept`
///
/// Accepts an assigned, valid service request. On first acceptance it creates a new confirmed record, invalidates previous records for the slot, adjusts related exchange requests and sends notifications. A comment is stored on first acceptance only if the service allows comments on confirmation. If already accepted, the same record is returned and its comment is updated. Requires permission to update the assignment.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ServiceRequestAnswer {
/// comment: Some(Some("Hallo zusammen".into())),
/// ..Default::default()
/// };
/// let service_request = client.events().service_requests().accept(42, 42, &body)?;
/// println!("{:?}", service_request.name);
/// # Ok(())
/// # }
/// ```
pub fn accept(&self, event_id: impl Display, request_id: impl Display, body: &models::ServiceRequestAnswer) -> Result<models::ServiceRequest> {
let path = format!("/events/{}/servicerequests/{}/accept", seg(event_id), seg(request_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Decline service request
///
/// `POST /events/{eventId}/servicerequests/{requestId}/decline`
///
/// Declines the current assignment, invalidates its `requestId` and returns a new unassigned record. Related exchange requests are deleted and notifications are sent. Assigned persons need `allowDecline` unless another permission grants access.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ServiceRequestAnswer {
/// comment: Some(Some("Hallo zusammen".into())),
/// ..Default::default()
/// };
/// let service_request = client.events().service_requests().decline(42, 42, &body)?;
/// println!("{:?}", service_request.name);
/// # Ok(())
/// # }
/// ```
pub fn decline(&self, event_id: impl Display, request_id: impl Display, body: &models::ServiceRequestAnswer) -> Result<models::ServiceRequest> {
let path = format!("/events/{}/servicerequests/{}/decline", seg(event_id), seg(request_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Undo service request
///
/// `POST /events/{eventId}/servicerequests/{requestId}/undo`
///
/// Reverts the last acceptance or decline to an outstanding request. Only the assigned person may do this. The legacy history must identify this as the last action and its timestamp must be within the 10-minute undo window; otherwise `400` is returned. For a decline, use the original declined request ID, not the new unassigned record returned by the decline operation.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ServiceRequestUndoCreate {
/// person_id: 42,
/// ..Default::default()
/// };
/// let service_request = client.events().service_requests().undo(42, 42, &body)?;
/// println!("{:?}", service_request.name);
/// # Ok(())
/// # }
/// ```
pub fn undo(&self, event_id: impl Display, request_id: impl Display, body: &models::ServiceRequestUndoCreate) -> Result<models::ServiceRequestUndoResult> {
let path = format!("/events/{}/servicerequests/{}/undo", seg(event_id), seg(request_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Update a service assignment
///
/// `PUT /events/{eventId}/servicerequests/{requestId}`
///
/// Creates a replacement assignment and invalidates the previous active record for the same event, service and slot index. Always use the returned ID for subsequent actions. `isAccepted`=`true` confirms it; `false` leaves it awaiting confirmation and does not decline it. Notifications follow the assignment workflow.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ServiceRequestUpdate {
/// name: Some(Some("Guest musician".into())),
/// ..Default::default()
/// };
/// let result = client.events().service_requests().update(42, 42, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, event_id: impl Display, request_id: impl Display, body: &models::ServiceRequestUpdate) -> Result<models::ServiceRequest> {
let path = format!("/events/{}/servicerequests/{}", seg(event_id), seg(request_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
/// Set service slot counts for an event
///
/// `PUT /events/{eventId}/servicerequests`
///
/// Changes the active slot count only for the listed service roles, in one transaction. Increasing a count creates unassigned slots. Decreasing it removes unassigned slots but retains occupied slots. A failed reduction returns `422` and rolls back the update; changing counts requires event administration or editing access for every affected service.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EventServicesUpdate {
/// services: vec![models::EventServiceCountUpdate {
/// count: 3,
/// service_id: 2,
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// client.events().service_requests().update_all(42, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update_all(&self, event_id: impl Display, body: &models::EventServicesUpdate) -> Result<()> {
let path = format!("/events/{}/servicerequests", seg(event_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.events().services()`
#[derive(Clone, Copy)]
pub struct EventsServicesResource<'a> {
client: &'a Client,
}
impl<'a> EventsServicesResource<'a> {
/// Get service candidates with planning hints
///
/// `GET /events/{eventId}/services/{serviceId}/possiblepersons`
///
/// Returns an unpaginated list of persons from active, visible-role memberships in groups connected to this reusable service role, narrowed by connected tags when present. Archived or deceased persons are excluded and hidden-person visibility is respected. Without permission to assign other persons, only the current user can appear. With no connected groups the list is empty.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-events-eventId-services-serviceId-possiblepersons");
/// for possible_person in client.events().services().list_possible_persons(42, 2)? {
/// println!("{}", possible_person.partner_services);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_possible_persons(&self, event_id: impl Display, service_id: impl Display) -> Result<Vec<models::PossibleEventPerson>> {
let path = format!("/events/{}/services/{}/possiblepersons", seg(event_id), seg(service_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.external_logins()`
#[derive(Clone, Copy)]
pub struct ExternalLoginsResource<'a> {
client: &'a Client,
}
impl<'a> ExternalLoginsResource<'a> {
pub fn link(&self) -> ExternalLoginsLinkResource<'a> {
ExternalLoginsLinkResource { client: self.client }
}
pub fn oidc(&self) -> ExternalLoginsOidcResource<'a> {
ExternalLoginsOidcResource { client: self.client }
}
pub fn saml(&self) -> ExternalLoginsSamlResource<'a> {
ExternalLoginsSamlResource { client: self.client }
}
/// Create an external login provider
///
/// `POST /externallogins`
///
/// Creates an OAuth, OpenID Connect or SAML provider configuration. Requires "churchcore administer settings" permission; SAML additionally requires the SAML settings feature flag. Logo discovery may contact the provider while saving. Only one provider can be primary.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ExternalLoginCreate {
/// config: serde_json::json!({"accessTokenUrl": "https://identity.example.org/accessTokenUrl", "authorizeUrl": "https://identity.example.org/authorizeUrl", "clientId": "churchtools", "urlResourceOwnerDetails": "https://identity.example.org/urlResourceOwnerDetails"}),
/// create_new_person: true,
/// has_registration: true,
/// name: "Organization login".into(),
/// new_person_campus_id: Some(42),
/// new_person_department_id: Some(42),
/// new_person_status_id: Some(42),
/// r#type: "oauth".into(),
/// update_data_on_login: true,
/// ..Default::default()
/// };
/// let result = client.external_logins().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ExternalLoginCreate) -> Result<models::ExternalLogin> {
let path = "/externallogins".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete an external login provider
///
/// `DELETE /externallogins/{externalLoginId}`
///
/// Deletes the provider configuration and its stored person-identity mappings. Requires "churchcore administer settings" permission; deleting a SAML provider also requires the SAML settings feature flag. ChurchTools persons and sessions at the external provider remain.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.external_logins().delete(7)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, external_login_id: impl Display) -> Result<()> {
let path = format!("/externallogins/{}", seg(external_login_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get an external login provider
///
/// `GET /externallogins/{externalLoginId}`
///
/// Returns one provider configuration. Requires "churchcore administer settings" permission. Hidden providers remain accessible. Client secrets and SAML SP private keys are not included.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-externallogins-id");
/// let external_login = client.external_logins().get(7)?;
/// println!("{}", external_login.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, external_login_id: impl Display) -> Result<models::ExternalLogin> {
let path = format!("/externallogins/{}", seg(external_login_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List external login providers
///
/// `GET /externallogins`
///
/// Returns all external login provider configurations, including hidden providers. Requires "churchcore administer settings" permission. Client secrets and SAML SP private keys are not included.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-externallogins");
/// for external_login in client.external_logins().list()? {
/// println!("{}", external_login.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::ExternalLogin>> {
let path = "/externallogins".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update an external login provider
///
/// `PUT /externallogins/{externalLoginId}`
///
/// Updates an existing provider. Requires "churchcore administer settings" permission; SAML changes additionally require the SAML settings feature flag. The protocol cannot be changed. Logo discovery is repeated, and setting `primaryLogin` does not demote another primary provider.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ExternalLoginUpdate {
/// config: serde_json::json!({"accessTokenUrl": "https://identity.example.org/accessTokenUrl", "authorizeUrl": "https://identity.example.org/authorizeUrl", "clientId": "churchtools", "urlResourceOwnerDetails": "https://identity.example.org/urlResourceOwnerDetails"}),
/// create_new_person: true,
/// has_registration: true,
/// name: "Nextcloud".into(),
/// new_person_campus_id: Some(42),
/// new_person_department_id: Some(42),
/// new_person_status_id: Some(42),
/// r#type: "oauth".into(),
/// update_data_on_login: true,
/// ..Default::default()
/// };
/// let result = client.external_logins().update(7, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, external_login_id: impl Display, body: &models::ExternalLoginUpdate) -> Result<models::ExternalLogin> {
let path = format!("/externallogins/{}", seg(external_login_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.external_logins().link()`
#[derive(Clone, Copy)]
pub struct ExternalLoginsLinkResource<'a> {
client: &'a Client,
}
impl<'a> ExternalLoginsLinkResource<'a> {
/// Verify and link an external identity
///
/// `POST /externallogins/{externalLoginId}/link`
///
/// Completes the verified_user_linking flow after a successful external identity-provider callback requested proof of a ChurchTools account. Requires the same browser session and pending linkToken, a visible provider in verified_user_linking mode, and valid credentials for an active, non-archived person. Tokens expire after 600 seconds; only ten pending links are retained per session. Each attempt clears any previous pending two-factor session. If the account uses two-factor authentication, no identity is linked yet: data.location points to the two-factor screen and POST /login/totp completes linking after verification. Otherwise the external identity is linked and the ChurchTools session is logged in. Navigate to data.location; this endpoint returns JSON rather than an HTTP redirect. The token is consumed after successful login. Credential failures can increment the account’s failed-login counter; the shared login rate limit also applies.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ExternalLoginLinkCreate {
/// link_token: "opaque-session-bound-link-token".into(),
/// password: "geheim".into(),
/// username: "alex@example.org".into(),
/// ..Default::default()
/// };
/// let result = client.external_logins().link().create(7, &body)?;
/// println!("{}", result.location);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, external_login_id: impl Display, body: &models::ExternalLoginLinkCreate) -> Result<models::ExternalLoginLinkResult> {
let path = format!("/externallogins/{}/link", seg(external_login_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Create a person for an external identity
///
/// `POST /externallogins/{externalLoginId}/link/create-person`
///
/// Creates a ChurchTools person from a pending verified external identity, links it and establishes the ChurchTools login session. Requires the same browser session and unexpired linkToken, a visible provider in verified_user_linking mode and createNewPerson enabled. Tokens expire after 600 seconds and are consumed after successful login. The external identity must not already be mapped. Person name, email and username come from the saved provider identity; department, campus and status come from the provider configuration. A nonblank last name is required by person creation. Returns JSON data.location for the client to navigate to. Person creation/mapping commit before session login, so a later completion error does not guarantee that no person was created.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ExternalLoginPersonCreate {
/// link_token: "opaque-session-bound-link-token".into(),
/// ..Default::default()
/// };
/// let result = client.external_logins().link().create_person(7, &body)?;
/// println!("{}", result.location);
/// # Ok(())
/// # }
/// ```
pub fn create_person(&self, external_login_id: impl Display, body: &models::ExternalLoginPersonCreate) -> Result<models::ExternalLoginLinkResult> {
let path = format!("/externallogins/{}/link/create-person", seg(external_login_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.external_logins().oidc()`
#[derive(Clone, Copy)]
pub struct ExternalLoginsOidcResource<'a> {
client: &'a Client,
}
impl<'a> ExternalLoginsOidcResource<'a> {
pub fn test(&self) -> ExternalLoginsOidcTestResource<'a> {
ExternalLoginsOidcTestResource { client: self.client }
}
/// Receive an OIDC back-channel logout
///
/// `POST /externallogins/oidc/backchannel-logout`
///
/// Accepts an OIDC Back-Channel Logout token signed by a configured provider. No browser session, CSRF token or API authentication is required. Issuer, audience, signature, lifetime, event and session/subject claims are checked. Matching local OIDC sessions are rejected on their next request. Repeated valid tokens and tokens without a matching local session succeed. Local password sessions remain unaffected. Responses have Cache-Control: no-store.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.external_logins().oidc().backchannel_logout()?;
/// # Ok(())
/// # }
/// ```
pub fn backchannel_logout(&self) -> Result<()> {
let path = "/externallogins/oidc/backchannel-logout".to_owned();
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Complete OIDC login through the stable callback
///
/// `GET /externallogins/oidc/callback`
///
/// Browser callback for OIDC Authorization Code login. The state resolves the provider from a pending flow in the same session; no provider ID is needed in this URL. State is consumed once before code exchange and expires after 600 seconds. The server validates the ID token, nonce and configured claim policies, then applies the provider’s person-matching mode. Success redirects to the stored safe local target; verified-user-linking mode can instead redirect to the local account-linking screen. A local matching/login failure can return an HTML 401 page, while protocol/state failures use plain-text 401 with a diagnostic ID. For administrator test flows, it records sanitized diagnostics and returns an HTML popup-completion page without creating/linking/logging in a person; the page itself does not indicate whether the test succeeded. Inspect the test-result endpoint.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetExternalloginsOidcCallbackQuery {
/// state: Some("opaque-session-bound-state".into()),
/// ..Default::default()
/// };
/// let data = client.external_logins().oidc().callback(&query)?;
/// std::fs::write("ergebnis.bin", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn callback(&self, query: &GetExternalloginsOidcCallbackQuery) -> Result<Vec<u8>> {
let path = "/externallogins/oidc/callback".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Complete OIDC login
///
/// `GET /externallogins/{externalLoginId}/oidc/callback`
///
/// Compatibility callback containing a provider ID. New flows use /api/externallogins/oidc/callback. The route ID must match the provider recorded for the state. Browser callback for OIDC Authorization Code login. The state resolves the provider from a pending flow in the same session; no provider ID is needed in this URL. State is consumed once before code exchange and expires after 600 seconds. The server validates the ID token, nonce and configured claim policies, then applies the provider’s person-matching mode. Success redirects to the stored safe local target; verified-user-linking mode can instead redirect to the local account-linking screen. A local matching/login failure can return an HTML 401 page, while protocol/state failures use plain-text 401 with a diagnostic ID. For administrator test flows, it records sanitized diagnostics and returns an HTML popup-completion page without creating/linking/logging in a person; the page itself does not indicate whether the test succeeded. Inspect the test-result endpoint.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetExternalloginsIdOidcCallbackQuery {
/// state: Some("opaque-session-bound-state".into()),
/// ..Default::default()
/// };
/// let data = client.external_logins().oidc().callback_for(7, &query)?;
/// std::fs::write("ergebnis.bin", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn callback_for(&self, external_login_id: impl Display, query: &GetExternalloginsIdOidcCallbackQuery) -> Result<Vec<u8>> {
let path = format!("/externallogins/{}/oidc/callback", seg(external_login_id));
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Start a browser-based OpenID Connect login
///
/// `GET /externallogins/{externalLoginId}/oidc/start`
///
/// Starts Authorization Code login for a visible OIDC provider using S256 PKCE, state and nonce. No existing ChurchTools login token is required. The pending flow is bound to the current browser session for 600 seconds; keep its cookie through the provider redirect and callback. At most ten pending OIDC authorizations/tests are retained per session, with older entries evicted. The configured issuer is discovered before returning the authorization URL. New flows use the stable /api/externallogins/oidc/callback URL. If the Accept header contains application/json, returns authorization details as JSON; otherwise redirects to the provider. Missing, hidden, wrong-type or unusable providers all use the same 404 text response.
///
/// Use [`Self::get_start_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let start = client.external_logins().oidc().get_start(7)?;
/// println!("{}", start.expires_at);
/// # Ok(())
/// # }
/// ```
pub fn get_start(&self, external_login_id: impl Display) -> Result<models::ExternalLoginAuthorizationStart> {
self.get_start_with(external_login_id, &Default::default())
}
/// Start a browser-based OpenID Connect login
///
/// Like [`Self::get_start`], with query parameters.
///
/// `GET /externallogins/{externalLoginId}/oidc/start`
///
/// Starts Authorization Code login for a visible OIDC provider using S256 PKCE, state and nonce. No existing ChurchTools login token is required. The pending flow is bound to the current browser session for 600 seconds; keep its cookie through the provider redirect and callback. At most ten pending OIDC authorizations/tests are retained per session, with older entries evicted. The configured issuer is discovered before returning the authorization URL. New flows use the stable /api/externallogins/oidc/callback URL. If the Accept header contains application/json, returns authorization details as JSON; otherwise redirects to the provider. Missing, hidden, wrong-type or unusable providers all use the same 404 text response.
pub fn get_start_with(&self, external_login_id: impl Display, query: &GetExternalloginsIdOidcStartQuery) -> Result<models::ExternalLoginAuthorizationStart> {
let path = format!("/externallogins/{}/oidc/start", seg(external_login_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.external_logins().oidc().test()`
#[derive(Clone, Copy)]
pub struct ExternalLoginsOidcTestResource<'a> {
client: &'a Client,
}
impl<'a> ExternalLoginsOidcTestResource<'a> {
/// Start OIDC login test
///
/// `POST /externallogins/{externalLoginId}/oidc/test`
///
/// Starts an OIDC Authorization Code test using the stored provider configuration. Requires "churchcore administer settings" permission. Hidden OIDC providers can be tested. Returns a URL to open in the same browser session and an opaque state for polling; preserve the session cookie through the provider callback. The pending flow expires after 600 seconds and shares the session limit of ten pending authorizations. This performs issuer discovery and token validation but does not create or link a person or establish a new ChurchTools login. Errors during authorization preparation are returned as data.status=error with HTTP 200; provider lookup errors occur before that conversion.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let result = client.external_logins().oidc().test().create(7)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, external_login_id: impl Display) -> Result<serde_json::Value> {
let path = format!("/externallogins/{}/oidc/test", seg(external_login_id));
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Get OIDC login test result
///
/// `GET /externallogins/{externalLoginId}/oidc/test/{state}`
///
/// Polls an OIDC test started by the current administrator for this provider in the same browser session. Requires "churchcore administer settings" permission and an existing OIDC provider; hidden providers are allowed. Returns pending until the callback completes, then success with claim names or error with a sanitized category. Unknown states, another session/administrator/provider, or expired pending authorizations return data.status=expired with HTTP 200. Pending states expire after 600 seconds. Completed results are not consumed by reads; the current implementation only prunes their age when another test result is stored, so expiresAt is not a strict expiry for completed results. No claim values or tokens are exposed.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-externallogins-id-oidc-test-state");
/// let test = client.external_logins().oidc().test().get(7, "opaque-session-bound-state")?;
/// println!("{:?}", test.error_code);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, external_login_id: impl Display, state: impl Display) -> Result<models::ExternalLoginOidcTestResult> {
let path = format!("/externallogins/{}/oidc/test/{}", seg(external_login_id), seg(state));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.external_logins().saml()`
#[derive(Clone, Copy)]
pub struct ExternalLoginsSamlResource<'a> {
client: &'a Client,
}
impl<'a> ExternalLoginsSamlResource<'a> {
pub fn metadata(&self) -> ExternalLoginsSamlMetadataResource<'a> {
ExternalLoginsSamlMetadataResource { client: self.client }
}
pub fn test(&self) -> ExternalLoginsSamlTestResource<'a> {
ExternalLoginsSamlTestResource { client: self.client }
}
/// Consume a SAML authentication response
///
/// `POST /externallogins/{externalLoginId}/saml/acs`
///
/// Public assertion-consumer callback for the identity provider’s form POST. Validates the SAML response and maps the external identity to a ChurchTools person. Successful login redirects to the stored destination or the installation landing page; identities needing account linking are redirected into that flow instead. Normal login requires a visible provider. Administrator test flows can use hidden providers and return a small HTML page that closes the popup, without logging the tested identity in. Test failures can also return that 200 HTML page: read the separate test-result endpoint for the outcome. A pending administrator test with missing RelayState also returns the popup page. Normal failures return 401 as localized text or an HTML error page, never the usual JSON error envelope.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.external_logins().saml().acs(7)?;
/// std::fs::write("ergebnis.bin", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn acs(&self, external_login_id: impl Display) -> Result<Vec<u8>> {
let path = format!("/externallogins/{}/saml/acs", seg(external_login_id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None)
}
/// Process a SAML single-logout message
///
/// `POST /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. Prefer the GET binding for new integrations. A redirect does not confirm successful logout.
///
/// Use [`Self::create_sls_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.external_logins().saml().create_sls(7)?;
/// # Ok(())
/// # }
/// ```
pub fn create_sls(&self, external_login_id: impl Display) -> Result<()> {
self.create_sls_with(external_login_id, &Default::default())
}
/// Process a SAML single-logout message
///
/// Like [`Self::create_sls`], with query parameters.
///
/// `POST /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. Prefer the GET binding for new integrations. A redirect does not confirm successful logout.
pub fn create_sls_with(&self, external_login_id: impl Display, query: &PostExternalloginsExternalLoginIdSamlSlsQuery) -> Result<()> {
let path = format!("/externallogins/{}/saml/sls", seg(external_login_id));
let query: Query = query.to_query();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Process a SAML single-logout message
///
/// `DELETE /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. Prefer the GET binding for new integrations. A redirect does not confirm successful logout.
///
/// Use [`Self::delete_sls_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.external_logins().saml().delete_sls(7)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_sls(&self, external_login_id: impl Display) -> Result<()> {
self.delete_sls_with(external_login_id, &Default::default())
}
/// Process a SAML single-logout message
///
/// Like [`Self::delete_sls`], with query parameters.
///
/// `DELETE /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. Prefer the GET binding for new integrations. A redirect does not confirm successful logout.
pub fn delete_sls_with(&self, external_login_id: impl Display, query: &DeleteExternalloginsExternalLoginIdSamlSlsQuery) -> Result<()> {
let path = format!("/externallogins/{}/saml/sls", seg(external_login_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Start a SAML browser login
///
/// `GET /externallogins/{externalLoginId}/saml/login`
///
/// Starts the browser-based SAML login for a visible SAML external-login provider. Redirects to the configured identity provider with a SAML authentication request and an opaque RelayState. An optional post-login redirect is saved in the browser session, so the callback must retain that session. Only absolute URLs on this installation’s origin and within its base path are accepted; invalid redirect values are ignored. Missing, hidden or invalid providers and other setup failures produce a localized 404 response. No login or JSON access token is returned by this endpoint itself.
///
/// Use [`Self::get_login_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.external_logins().saml().get_login(7)?;
/// # Ok(())
/// # }
/// ```
pub fn get_login(&self, external_login_id: impl Display) -> Result<()> {
self.get_login_with(external_login_id, &Default::default())
}
/// Start a SAML browser login
///
/// Like [`Self::get_login`], with query parameters.
///
/// `GET /externallogins/{externalLoginId}/saml/login`
///
/// Starts the browser-based SAML login for a visible SAML external-login provider. Redirects to the configured identity provider with a SAML authentication request and an opaque RelayState. An optional post-login redirect is saved in the browser session, so the callback must retain that session. Only absolute URLs on this installation’s origin and within its base path are accepted; invalid redirect values are ignored. Missing, hidden or invalid providers and other setup failures produce a localized 404 response. No login or JSON access token is returned by this endpoint itself.
pub fn get_login_with(&self, external_login_id: impl Display, query: &GetExternalloginsExternalLoginIdSamlLoginQuery) -> Result<()> {
let path = format!("/externallogins/{}/saml/login", seg(external_login_id));
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
/// Get SAML service-provider metadata
///
/// `GET /externallogins/{externalLoginId}/saml/metadata`
///
/// Returns the XML metadata that an identity-provider administrator uses to configure ChurchTools as a SAML service provider. The entity ID, assertion-consumer URL and logout URL refer to this external-login provider. This endpoint is public and also works for a hidden provider, allowing setup before enabling login. Any provider/configuration/metadata-generation failure is returned as 404 with localized text, not a JSON error envelope.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.external_logins().saml().get_metadata(7)?;
/// std::fs::write("ergebnis.bin", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_metadata(&self, external_login_id: impl Display) -> Result<Vec<u8>> {
let path = format!("/externallogins/{}/saml/metadata", seg(external_login_id));
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None)
}
/// Process a SAML single-logout message
///
/// `GET /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. A redirect does not confirm successful logout.
///
/// Use [`Self::get_sls_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.external_logins().saml().get_sls(7)?;
/// # Ok(())
/// # }
/// ```
pub fn get_sls(&self, external_login_id: impl Display) -> Result<()> {
self.get_sls_with(external_login_id, &Default::default())
}
/// Process a SAML single-logout message
///
/// Like [`Self::get_sls`], with query parameters.
///
/// `GET /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. A redirect does not confirm successful logout.
pub fn get_sls_with(&self, external_login_id: impl Display, query: &GetExternalloginsExternalLoginIdSamlSlsQuery) -> Result<()> {
let path = format!("/externallogins/{}/saml/sls", seg(external_login_id));
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
/// Process a SAML single-logout message
///
/// `PATCH /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. Prefer the GET binding for new integrations. A redirect does not confirm successful logout.
///
/// Use [`Self::patch_sls_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.external_logins().saml().patch_sls(7)?;
/// # Ok(())
/// # }
/// ```
pub fn patch_sls(&self, external_login_id: impl Display) -> Result<()> {
self.patch_sls_with(external_login_id, &Default::default())
}
/// Process a SAML single-logout message
///
/// Like [`Self::patch_sls`], with query parameters.
///
/// `PATCH /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. Prefer the GET binding for new integrations. A redirect does not confirm successful logout.
pub fn patch_sls_with(&self, external_login_id: impl Display, query: &PatchExternalloginsExternalLoginIdSamlSlsQuery) -> Result<()> {
let path = format!("/externallogins/{}/saml/sls", seg(external_login_id));
let query: Query = query.to_query();
self.client.request(Method::Patch, &path, &query, None).map(|_| ())
}
/// Process a SAML single-logout message
///
/// `PUT /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. Prefer the GET binding for new integrations. A redirect does not confirm successful logout.
///
/// Use [`Self::update_sls_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.external_logins().saml().update_sls(7)?;
/// # Ok(())
/// # }
/// ```
pub fn update_sls(&self, external_login_id: impl Display) -> Result<()> {
self.update_sls_with(external_login_id, &Default::default())
}
/// Process a SAML single-logout message
///
/// Like [`Self::update_sls`], with query parameters.
///
/// `PUT /externallogins/{externalLoginId}/saml/sls`
///
/// Processes a signed SAML HTTP-Redirect single-logout message for a visible provider. Prefer the GET binding for new integrations. A redirect does not confirm successful logout.
pub fn update_sls_with(&self, external_login_id: impl Display, query: &PutExternalloginsExternalLoginIdSamlSlsQuery) -> Result<()> {
let path = format!("/externallogins/{}/saml/sls", seg(external_login_id));
let query: Query = query.to_query();
self.client.request(Method::Put, &path, &query, None).map(|_| ())
}
}
/// `client.external_logins().saml().metadata()`
#[derive(Clone, Copy)]
pub struct ExternalLoginsSamlMetadataResource<'a> {
client: &'a Client,
}
impl<'a> ExternalLoginsSamlMetadataResource<'a> {
/// Parse uploaded SAML identity-provider metadata
///
/// `POST /externallogins/saml/metadata/parse`
///
/// Parses supplied XML into selectable IdP configuration candidates. Requires "churchcore administer settings" permission. Supports `EntityDescriptor` and `EntitiesDescriptor` documents and HTTP-Redirect SSO/SLO bindings. Parsing does not verify metadata signatures or certificate trust.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SamlMetadataParseCreate {
/// xml: "beispiel".into(),
/// ..Default::default()
/// };
/// let metadata = client.external_logins().saml().metadata().parse(&body)?;
/// println!("{:?}", metadata);
/// # Ok(())
/// # }
/// ```
pub fn parse(&self, body: &models::SamlMetadataParseCreate) -> Result<models::PostExternalloginsSamlMetadataParseData> {
let path = "/externallogins/saml/metadata/parse".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.external_logins().saml().test()`
#[derive(Clone, Copy)]
pub struct ExternalLoginsSamlTestResource<'a> {
client: &'a Client,
}
impl<'a> ExternalLoginsSamlTestResource<'a> {
/// Start SAML login test
///
/// `POST /externallogins/{externalLoginId}/saml/test`
///
/// Starts a SAML round-trip test for the stored provider configuration. Requires "churchcore administer settings" permission; hidden SAML providers can be tested. Open data.url in the same browser session, then poll using data.state. At most five tests are retained per session; older entries are evicted. Tests and completed results expire 600 seconds after creation. The callback validates the SAML response and returns claim-name/mapping diagnostics without creating or linking a ChurchTools person or establishing a new ChurchTools login. A successful test does not guarantee that required identity attributes have usable values or that person matching would succeed. Configuration/URL-generation failures are not converted into an error result by this endpoint.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let result = client.external_logins().saml().test().create(7)?;
/// println!("{}", result.expires_at);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, external_login_id: impl Display) -> Result<models::ExternalLoginSamlTestStart> {
let path = format!("/externallogins/{}/saml/test", seg(external_login_id));
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Get SAML login test result
///
/// `GET /externallogins/{externalLoginId}/saml/test/{state}`
///
/// Polls a SAML test for the current administrator, provider and browser session. Requires "churchcore administer settings" permission; hidden SAML providers are allowed. An unknown state, another administrator/provider/session, an evicted test, or a test older than 600 seconds returns status=expired with HTTP 200. Success returns attribute names and all five mapping-presence checks; error returns only its status. Reads do not consume completed results. Provider lookup and SAML configuration are checked again, so deleting the provider or breaking its settings can prevent polling an existing result.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-externallogins-id-saml-test-state");
/// let test = client.external_logins().saml().test().get(7, "beispiel")?;
/// println!("{}", test.status);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, external_login_id: impl Display, state: impl Display) -> Result<models::ExternalLoginSamlTestResult> {
let path = format!("/externallogins/{}/saml/test/{}", seg(external_login_id), seg(state));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.external_posts()`
#[derive(Clone, Copy)]
pub struct ExternalPostsResource<'a> {
client: &'a Client,
}
impl<'a> ExternalPostsResource<'a> {
pub fn instances(&self) -> ExternalPostsInstancesResource<'a> {
ExternalPostsInstancesResource { client: self.client }
}
/// `GET /externalposts`
///
/// Get a list of external posts. The posts are sorted by the `createdDate` field descending.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-externalposts");
/// for external_post in client.external_posts().list()? {
/// println!("{}", external_post.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Post>> {
self.list_with(&Default::default())
}
/// `GET /externalposts`
///
/// Like [`Self::list`], with query parameters.
///
/// Get a list of external posts. The posts are sorted by the `createdDate` field descending.
pub fn list_with(&self, query: &GetExternalpostsQuery) -> Result<Vec<models::Post>> {
let path = "/externalposts".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.external_posts().instances()`
#[derive(Clone, Copy)]
pub struct ExternalPostsInstancesResource<'a> {
client: &'a Client,
}
impl<'a> ExternalPostsInstancesResource<'a> {
pub fn channels(&self) -> ExternalPostsInstancesChannelsResource<'a> {
ExternalPostsInstancesChannelsResource { client: self.client }
}
}
/// `client.external_posts().instances().channels()`
#[derive(Clone, Copy)]
pub struct ExternalPostsInstancesChannelsResource<'a> {
client: &'a Client,
}
impl<'a> ExternalPostsInstancesChannelsResource<'a> {
pub fn posts(&self) -> ExternalPostsInstancesChannelsPostsResource<'a> {
ExternalPostsInstancesChannelsPostsResource { client: self.client }
}
}
/// `client.external_posts().instances().channels().posts()`
#[derive(Clone, Copy)]
pub struct ExternalPostsInstancesChannelsPostsResource<'a> {
client: &'a Client,
}
impl<'a> ExternalPostsInstancesChannelsPostsResource<'a> {
/// `GET /externalposts/instances/{instanceGuid}/channels/{channelGuid}/posts/{postGuid}`
///
/// Get one external Post
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let post = client.external_posts().instances().channels().posts().get("abc123", "abc123", "abc123")?;
/// println!("{}", post.title);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, instance_guid: impl Display, channel_guid: impl Display, post_guid: impl Display) -> Result<models::Post> {
let path = format!("/externalposts/instances/{}/channels/{}/posts/{}", seg(instance_guid), seg(channel_guid), seg(post_guid));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.facts()`
#[derive(Clone, Copy)]
pub struct FactsResource<'a> {
client: &'a Client,
}
impl<'a> FactsResource<'a> {
/// Create a fact definition
///
/// `POST /facts`
///
/// Creates a reusable metric or selection definition. Values for individual events are managed separately. Requires the "edit masterdata" permission for the service planning domain.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-facts");
/// let body = serde_json::json!({
/// "name": "Attendance",
/// "type": "number",
/// "unit": "people"
/// });
/// let result = client.facts().create(&body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &serde_json::Value) -> Result<serde_json::Value> {
let path = "/facts".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a fact definition
///
/// `DELETE /facts/{id}`
///
/// Deletes the reusable definition, all values recorded for it on events, its assignments in event templates and its fact-specific permissions. To remove only one recorded value, use `DELETE /events/{eventId}/facts/{factId}`. With `dry_run`=`true`, no deletion is performed and the API returns `409` with a deletion report even when deletable is `true`. A successful actual deletion returns `204`. Requires permission to edit service-planning master data (the "edit masterdata" permission for the service planning domain).
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.facts().delete(3)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete a fact definition
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /facts/{id}`
///
/// Deletes the reusable definition, all values recorded for it on events, its assignments in event templates and its fact-specific permissions. To remove only one recorded value, use `DELETE /events/{eventId}/facts/{factId}`. With `dry_run`=`true`, no deletion is performed and the API returns `409` with a deletion report even when deletable is `true`. A successful actual deletion returns `204`. Requires permission to edit service-planning master data (the "edit masterdata" permission for the service planning domain).
pub fn delete_with(&self, id: impl Display, query: &DeleteFactsIdQuery) -> Result<()> {
let path = format!("/facts/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a fact definition
///
/// `GET /facts/{id}`
///
/// Returns the reusable definition, including the numeric unit or available selection labels. This does not return values recorded for events and does not check permission to view those values.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-facts-id");
/// let result = client.facts().get(3)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<serde_json::Value> {
let path = format!("/facts/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List fact definitions
///
/// `GET /facts`
///
/// A fact definition describes a reusable metric (number) or selection (select), such as attendance or service type. It is separate from the value recorded for an individual event. Returns all definitions, ordered by `sortKey` ascending and then name ascending, without pagination. Definitions are not filtered by permissions to view recorded fact values.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-facts");
/// for fact in client.facts().list()? {
/// println!("{:?}", fact);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<serde_json::Value>> {
let path = "/facts".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Replace a fact definition
///
/// `PUT /facts/{id}`
///
/// Replaces the definition’s name, type, sort order and type-specific settings. Stored event values are not migrated or validated against a changed type or option list. Requires the "edit masterdata" permission for the service planning domain; permission to edit an individual fact value is not sufficient.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-facts-id");
/// let body = serde_json::json!({
/// "name": "Attendance",
/// "type": "number",
/// "unit": "people"
/// });
/// let result = client.facts().update(3, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &serde_json::Value) -> Result<serde_json::Value> {
let path = format!("/facts/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.feature_usage()`
#[derive(Clone, Copy)]
pub struct FeatureUsageResource<'a> {
client: &'a Client,
}
impl<'a> FeatureUsageResource<'a> {
/// `POST /featureusage`
///
/// Send feature usage statistics in bulk.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostFeatureusageBody::default();
/// client.feature_usage().create(&body)?;
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::PostFeatureusageBody) -> Result<()> {
let path = "/featureusage".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.fields()`
#[derive(Clone, Copy)]
pub struct FieldsResource<'a> {
client: &'a Client,
}
impl<'a> FieldsResource<'a> {
/// Get all fields
///
/// `GET /fields`
///
/// Returns an array of all fields defined in ChurchTools.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-fields");
/// for field in client.fields().list()? {
/// println!("{:?}", field);
/// }
/// # Ok(())
/// # }
/// ```
#[deprecated = "GET /fields is deprecated in the ChurchTools API."]
pub fn list(&self) -> Result<Vec<std::collections::BTreeMap<String, serde_json::Value>>> {
let path = "/fields".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.files()`
#[derive(Clone, Copy)]
pub struct FilesResource<'a> {
client: &'a Client,
}
impl<'a> FilesResource<'a> {
/// Upload files
///
/// `POST /files/{domainType}/{domainIdentifier}`
///
/// Uploads files to a domain object. Requires update permission. The attachment category controls file multiplicity, image dimensions and category-specific processing.
///
/// Use [`Self::create_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let file = Upload::from_path("gemeindebrief.pdf")?;
/// for file in client.files().create(serde_json::json!("agenda_PRO_PRESENTER_6"), "42", &[file])? {
/// println!("{}", file.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn create(&self, domain_type: impl Display, domain_identifier: impl Display, files: &[Upload]) -> Result<Vec<models::FileUploadResult>> {
self.create_with(domain_type, domain_identifier, files, &Default::default())
}
/// Upload files
///
/// Like [`Self::create`], with form fields.
///
/// `POST /files/{domainType}/{domainIdentifier}`
///
/// Uploads files to a domain object. Requires update permission. The attachment category controls file multiplicity, image dimensions and category-specific processing.
pub fn create_with(&self, domain_type: impl Display, domain_identifier: impl Display, files: &[Upload], form: &PostFilesDomainTypeDomainIdentifierForm) -> Result<Vec<models::FileUploadResult>> {
let path = format!("/files/{}/{}", seg(domain_type), seg(domain_identifier));
let query: Query = Query::new();
let form: Query = form.to_query();
let bytes = self.client.request_multipart(Method::Post, &path, &query, &form, "files[]", files)?;
crate::decode_data(&bytes)
}
/// Delete a file by ID
///
/// `DELETE /files/{id}`
///
/// Deletes one file or URL attachment. Requires update permission for its owning object and runs category-specific delete hooks.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.files().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
let path = format!("/files/{}", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Delete all files for a domain object
///
/// `DELETE /files/{domainType}/{domainIdentifier}`
///
/// Deletes every file and URL attachment of the domain object. Requires update permission for the object and runs category-specific delete hooks.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.files().delete_for_object(serde_json::json!("agenda_PRO_PRESENTER_6"), "42")?;
/// # Ok(())
/// # }
/// ```
pub fn delete_for_object(&self, domain_type: impl Display, domain_identifier: impl Display) -> Result<()> {
let path = format!("/files/{}/{}", seg(domain_type), seg(domain_identifier));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get file metadata by ID
///
/// `GET /files/{id}/meta`
///
/// Returns normalized metadata for a file or URL attachment. Requires view permission for the file. Anonymous access depends on the attachment category.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-files-id-meta");
/// let meta = client.files().get_meta(1)?;
/// println!("{}", meta.name);
/// # Ok(())
/// # }
/// ```
pub fn get_meta(&self, id: impl Display) -> Result<models::CtFile> {
let path = format!("/files/{}/meta", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get legacy file metadata
///
/// `GET /files/{fileId}/metadata`
///
/// Returns the raw file database record without a response envelope. Use `GET /files/{id}/meta` for normalized file metadata.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-files-id-metadata");
/// let metadata = client.files().get_metadata(42)?;
/// println!("{}", metadata.id);
/// # Ok(())
/// # }
/// ```
#[deprecated = "GET /files/{fileId}/metadata is deprecated in the ChurchTools API. Use `GET /files/{id}/meta` for normalized file metadata."]
pub fn get_metadata(&self, file_id: impl Display) -> Result<models::LegacyFileMetadata> {
let path = format!("/files/{}/metadata", seg(file_id));
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
/// Add a link attachment
///
/// `POST /files/{domainType}/{domainIdentifier}/link`
///
/// Creates a URL attachment without fetching its target. Requires update permission and runs the selected category's file-save hooks.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::FileLinkCreate {
/// url: "https://example.org/service-notes".into(),
/// ..Default::default()
/// };
/// let file = client.files().link(serde_json::json!("agenda_PRO_PRESENTER_6"), "42", &body)?;
/// println!("{}", file.name);
/// # Ok(())
/// # }
/// ```
pub fn link(&self, domain_type: impl Display, domain_identifier: impl Display, body: &models::FileLinkCreate) -> Result<models::CtFile> {
let path = format!("/files/{}/{}/link", seg(domain_type), seg(domain_identifier));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get all files for a specific domain object
///
/// `GET /files/{domainType}/{domainIdentifier}`
///
/// Returns metadata for files and URL attachments of one domain object. Files hidden by view permissions or `showOnlyWhenEditable` are omitted. Anonymous access depends on the selected attachment category.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-files-domainType-domainIdentifier");
/// for file in client.files().list(serde_json::json!("agenda_PRO_PRESENTER_6"), "42")? {
/// println!("{}", file.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, domain_type: impl Display, domain_identifier: impl Display) -> Result<Vec<models::CtFile>> {
let path = format!("/files/{}/{}", seg(domain_type), seg(domain_identifier));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all files for a domain type
///
/// `GET /files/{domainType}`
///
/// Returns file and URL-attachment metadata for one attachment category. Files hidden by view permissions or `showOnlyWhenEditable` are omitted.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-files-domainType");
/// let result = client.files().list_for_type(serde_json::json!("agenda_PRO_PRESENTER_6"))?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn list_for_type(&self, domain_type: impl Display) -> Result<serde_json::Value> {
let path = format!("/files/{}", seg(domain_type));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update file metadata by ID
///
/// `PATCH /files/{id}`
///
/// Updates a file's display metadata and optionally copies it to another attachment context. Updating requires source update permission; copying requires source view permission and target update permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::FileUpdate {
/// name: Some(Some("Service notes.pdf".into())),
/// ..Default::default()
/// };
/// client.files().patch(1, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, id: impl Display, body: &models::FileUpdate) -> Result<()> {
let path = format!("/files/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Patch, &path, &query, Some(&body)).map(|_| ())
}
/// Update files for a domain object
///
/// `PATCH /files/{domainType}/{domainIdentifier}`
///
/// Updates the display name and sort key of every attachment of the domain object. Requires update permission and runs category-specific metadata hooks for each affected file.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::FileDomainUpdate {
/// name: Some(Some("Service notes.pdf".into())),
/// ..Default::default()
/// };
/// client.files().update_for_object(serde_json::json!("agenda_PRO_PRESENTER_6"), "42", &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update_for_object(&self, domain_type: impl Display, domain_identifier: impl Display, body: &models::FileDomainUpdate) -> Result<()> {
let path = format!("/files/{}/{}", seg(domain_type), seg(domain_identifier));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Patch, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.finance()`
#[derive(Clone, Copy)]
pub struct FinanceResource<'a> {
client: &'a Client,
}
impl<'a> FinanceResource<'a> {
pub fn account_classes(&self) -> FinanceAccountClassesResource<'a> {
FinanceAccountClassesResource { client: self.client }
}
pub fn account_groups(&self) -> FinanceAccountGroupsResource<'a> {
FinanceAccountGroupsResource { client: self.client }
}
pub fn account_types(&self) -> FinanceAccountTypesResource<'a> {
FinanceAccountTypesResource { client: self.client }
}
pub fn accounting_periods(&self) -> FinanceAccountingPeriodsResource<'a> {
FinanceAccountingPeriodsResource { client: self.client }
}
pub fn accounts(&self) -> FinanceAccountsResource<'a> {
FinanceAccountsResource { client: self.client }
}
pub fn bills(&self) -> FinanceBillsResource<'a> {
FinanceBillsResource { client: self.client }
}
pub fn cash_discounts(&self) -> FinanceCashDiscountsResource<'a> {
FinanceCashDiscountsResource { client: self.client }
}
pub fn clients(&self) -> FinanceClientsResource<'a> {
FinanceClientsResource { client: self.client }
}
pub fn cost_centers(&self) -> FinanceCostCentersResource<'a> {
FinanceCostCentersResource { client: self.client }
}
pub fn donators(&self) -> FinanceDonatorsResource<'a> {
FinanceDonatorsResource { client: self.client }
}
pub fn eubp(&self) -> FinanceEubpResource<'a> {
FinanceEubpResource { client: self.client }
}
pub fn reports(&self) -> FinanceReportsResource<'a> {
FinanceReportsResource { client: self.client }
}
pub fn split_transactions(&self) -> FinanceSplitTransactionsResource<'a> {
FinanceSplitTransactionsResource { client: self.client }
}
pub fn tax_rates(&self) -> FinanceTaxRatesResource<'a> {
FinanceTaxRatesResource { client: self.client }
}
pub fn tax_types(&self) -> FinanceTaxTypesResource<'a> {
FinanceTaxTypesResource { client: self.client }
}
pub fn templates(&self) -> FinanceTemplatesResource<'a> {
FinanceTemplatesResource { client: self.client }
}
pub fn transaction_purposes(&self) -> FinanceTransactionPurposesResource<'a> {
FinanceTransactionPurposesResource { client: self.client }
}
pub fn transactions(&self) -> FinanceTransactionsResource<'a> {
FinanceTransactionsResource { client: self.client }
}
/// Get finance master data for an accounting period
///
/// `GET /finance/masterdata`
///
/// Finance definitions needed for one accounting period. Clients and periods include all entries visible to the caller; account types, classes, groups and tax types are installation-wide. Accounts, cost centers, tax rates, cash discounts and transaction purposes relate to the selected period. The selected accounting period must be visible. Returns data, per-collection counts in meta and top-level UI permissions. Account balances are calculated only with global view/edit accounting period permission; otherwise account values may remain at their uncalculated defaults. Cost-center budgets are calculated independently. Unlike /finance/transactionpurposes, the preset list is restricted by period and, without global period rights, by groups allowing posting.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-masterdata");
/// let query = GetFinanceMasterdataQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let master_data = client.finance().get_master_data(&query)?;
/// println!("{:?}", master_data);
/// # Ok(())
/// # }
/// ```
pub fn get_master_data(&self, query: &GetFinanceMasterdataQuery) -> Result<models::FinanceMasterData> {
let path = "/finance/masterdata".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.finance().account_classes()`
#[derive(Clone, Copy)]
pub struct FinanceAccountClassesResource<'a> {
client: &'a Client,
}
impl<'a> FinanceAccountClassesResource<'a> {
/// Create a new account class
///
/// `POST /finance/accountclasses`
///
/// Creates finance master data. Account classes group account groups within one account type. The hierarchy is account type → account class → account group → account. Requires finance “edit masterdata”. Names must be unique across this resource. The successful response uses HTTP 200.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountClassCreate {
/// account_type_id: 3,
/// name: "Anlagevermögen".into(),
/// ..Default::default()
/// };
/// let result = client.finance().account_classes().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::AccountClassCreate) -> Result<models::AccountClass> {
let path = "/finance/accountclasses".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete an account class
///
/// `DELETE /finance/accountclasses/{id}`
///
/// Deletes this definition if no account groups reference it. Requires finance “edit masterdata”. With dry_run=true no deletion occurs and HTTP 409 returns the conflict report, including when deletion would be allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().account_classes().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete an account class
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/accountclasses/{id}`
///
/// Deletes this definition if no account groups reference it. Requires finance “edit masterdata”. With dry_run=true no deletion occurs and HTTP 409 returns the conflict report, including when deletion would be allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceAccountclassesIdQuery) -> Result<()> {
let path = format!("/finance/accountclasses/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get an account class by ID
///
/// `GET /finance/accountclasses/{id}`
///
/// Account classes group account groups within one account type. The hierarchy is account type → account class → account group → account. Returns one definition by ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountclasses-id");
/// let account_class = client.finance().account_classes().get(1)?;
/// println!("{}", account_class.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::AccountClass> {
let path = format!("/finance/accountclasses/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all account classs
///
/// `GET /finance/accountclasses`
///
/// Account classes group account groups within one account type. The hierarchy is account type → account class → account group → account. Returns the complete, unpaginated list ordered by sortKey, then name, ascending. meta.count is the number returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountclasses");
/// for account_class in client.finance().account_classes().list()? {
/// println!("{}", account_class.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::AccountClass>> {
let path = "/finance/accountclasses".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update an account class
///
/// `PUT /finance/accountclasses/{id}`
///
/// Replaces the editable fields of this definition. Requires finance “edit masterdata”. Names must remain unique. Omitted optional fields are reset to their defaults. includeProfitLoss defaults to false and may be enabled on at most one class.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountClassUpdate {
/// account_type_id: 3,
/// name: "Anlagevermögen".into(),
/// ..Default::default()
/// };
/// let result = client.finance().account_classes().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::AccountClassUpdate) -> Result<models::AccountClass> {
let path = format!("/finance/accountclasses/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().account_groups()`
#[derive(Clone, Copy)]
pub struct FinanceAccountGroupsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceAccountGroupsResource<'a> {
/// Create new account group
///
/// `POST /finance/accountgroups`
///
/// Creates finance master data. Account groups collect individual ledger accounts within one account class. isCashAssetAccount identifies groups of cash or bank accounts. Requires finance “edit masterdata”. Names must be unique across this resource. The successful response uses HTTP 200.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountGroupCreate {
/// account_class_id: 2,
/// is_cash_asset_account: false,
/// name: "Sachanlagen".into(),
/// ..Default::default()
/// };
/// let result = client.finance().account_groups().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::AccountGroupCreate) -> Result<models::AccountGroup> {
let path = "/finance/accountgroups".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete account group
///
/// `DELETE /finance/accountgroups/{id}`
///
/// Deletes this definition if no accounts reference it. Requires finance “edit masterdata”. With dry_run=true no deletion occurs and HTTP 409 returns the conflict report, including when deletion would be allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().account_groups().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete account group
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/accountgroups/{id}`
///
/// Deletes this definition if no accounts reference it. Requires finance “edit masterdata”. With dry_run=true no deletion occurs and HTTP 409 returns the conflict report, including when deletion would be allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceAccountgroupsIdQuery) -> Result<()> {
let path = format!("/finance/accountgroups/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a account group
///
/// `GET /finance/accountgroups/{id}`
///
/// Account groups collect individual ledger accounts within one account class. isCashAssetAccount identifies groups of cash or bank accounts. Returns one definition by ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountgroups-id");
/// let account_group = client.finance().account_groups().get(1)?;
/// println!("{}", account_group.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::AccountGroup> {
let path = format!("/finance/accountgroups/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all account groups
///
/// `GET /finance/accountgroups`
///
/// Account groups collect individual ledger accounts within one account class. isCashAssetAccount identifies groups of cash or bank accounts. Returns the complete, unpaginated list ordered by sortKey, then name, ascending. meta.count is the number returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountgroups");
/// for account_group in client.finance().account_groups().list()? {
/// println!("{}", account_group.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::AccountGroup>> {
let path = "/finance/accountgroups".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update account group
///
/// `PUT /finance/accountgroups/{id}`
///
/// Replaces the editable fields of this definition. Requires finance “edit masterdata”. Names must remain unique. Omitted optional fields are reset to their defaults. sortKey defaults to 0.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountGroupUpdate {
/// account_class_id: 2,
/// is_cash_asset_account: false,
/// name: "Sachanlagen".into(),
/// ..Default::default()
/// };
/// let result = client.finance().account_groups().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::AccountGroupUpdate) -> Result<models::AccountGroup> {
let path = format!("/finance/accountgroups/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().account_types()`
#[derive(Clone, Copy)]
pub struct FinanceAccountTypesResource<'a> {
client: &'a Client,
}
impl<'a> FinanceAccountTypesResource<'a> {
/// Create new account type
///
/// `POST /finance/accounttypes`
///
/// Creates finance master data. Account types are the top level of the finance chart of accounts. They distinguish assets, liabilities and profit-and-loss accounts. Each account class belongs to one account type. Requires finance “edit masterdata”. Names must be unique across this resource. The successful response uses HTTP 200.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountTypeCreate {
/// name: "Aktiva".into(),
/// ..Default::default()
/// };
/// let result = client.finance().account_types().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::AccountTypeCreate) -> Result<models::AccountType> {
let path = "/finance/accounttypes".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete account type
///
/// `DELETE /finance/accounttypes/{id}`
///
/// Deletes this definition if no account classes reference it. Requires finance “edit masterdata”. With dry_run=true no deletion occurs and HTTP 409 returns the conflict report, including when deletion would be allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().account_types().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete account type
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/accounttypes/{id}`
///
/// Deletes this definition if no account classes reference it. Requires finance “edit masterdata”. With dry_run=true no deletion occurs and HTTP 409 returns the conflict report, including when deletion would be allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceAccounttypesIdQuery) -> Result<()> {
let path = format!("/finance/accounttypes/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a account type
///
/// `GET /finance/accounttypes/{id}`
///
/// Account types are the top level of the finance chart of accounts. They distinguish assets, liabilities and profit-and-loss accounts. Each account class belongs to one account type. Returns one definition by ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accounttypes-id");
/// let account_type = client.finance().account_types().get(1)?;
/// println!("{}", account_type.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::AccountType> {
let path = format!("/finance/accounttypes/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all account types
///
/// `GET /finance/accounttypes`
///
/// Account types are the top level of the finance chart of accounts. They distinguish assets, liabilities and profit-and-loss accounts. Each account class belongs to one account type. Returns the complete, unpaginated list ordered by sortKey, then name, ascending. meta.count is the number returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accounttypes");
/// for account_type in client.finance().account_types().list()? {
/// println!("{}", account_type.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::AccountType>> {
let path = "/finance/accounttypes".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update account type
///
/// `PUT /finance/accounttypes/{id}`
///
/// Replaces the editable fields of this definition. Requires finance “edit masterdata”. Names must remain unique. Omitted optional fields are reset to their defaults. Omitting balanceType changes the type to profit-and-loss.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountTypeUpdate {
/// name: "Aktiva".into(),
/// ..Default::default()
/// };
/// let result = client.finance().account_types().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::AccountTypeUpdate) -> Result<models::AccountType> {
let path = format!("/finance/accounttypes/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().accounting_periods()`
#[derive(Clone, Copy)]
pub struct FinanceAccountingPeriodsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceAccountingPeriodsResource<'a> {
pub fn accounts(&self) -> FinanceAccountingPeriodsAccountsResource<'a> {
FinanceAccountingPeriodsAccountsResource { client: self.client }
}
pub fn statements(&self) -> FinanceAccountingPeriodsStatementsResource<'a> {
FinanceAccountingPeriodsStatementsResource { client: self.client }
}
/// Create new accounting period
///
/// `POST /finance/accountingperiods`
///
/// Creates an accounting period and optionally copies master data and transfers opening balances. Requires finance “edit masterdata”. The combination of clientId, startDate and endDate must be unique. Returns HTTP 201. Exceptions during creation, copying or balance transfer are rolled back and reported as HTTP 400, including a missing client.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountingPeriodCreate {
/// client_id: 1,
/// end_date: "2026-12-31".parse()?,
/// increment_document_number: true,
/// is_closed: false,
/// start_date: "2026-01-01".parse()?,
/// ..Default::default()
/// };
/// let result = client.finance().accounting_periods().create(&body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::AccountingPeriodCreate) -> Result<models::AccountingPeriod> {
let path = "/finance/accountingperiods".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete accounting period
///
/// `DELETE /finance/accountingperiods/{id}`
///
/// Deletes a period when its accounts no longer block deletion. Requires finance “edit masterdata”. The last accounting period in the installation cannot be deleted. Cost centers are treated as removable dependencies; associated authorization entries and donation receipts are cleaned up. dry_run=true returns the HTTP 409 conflict report without deleting, including when deletion is allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().accounting_periods().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete accounting period
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/accountingperiods/{id}`
///
/// Deletes a period when its accounts no longer block deletion. Requires finance “edit masterdata”. The last accounting period in the installation cannot be deleted. Cost centers are treated as removable dependencies; associated authorization entries and donation receipts are cleaned up. dry_run=true returns the HTTP 409 conflict report without deleting, including when deletion is allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceAccountingperiodsIdQuery) -> Result<()> {
let path = format!("/finance/accountingperiods/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Delete tax rates for accounting period
///
/// `DELETE /finance/accountingperiods/{id}/taxrates`
///
/// Deletes all tax rates whose receiving accounts belong to this accounting period. Requires finance “edit masterdata”. The operation first clears the default taxRateId of every account in the period, then deletes its tax rates in one transaction. References from transactions prevent deletion and return 400. An unknown or empty period succeeds without changes. Unlike single deletion, this operation does not support dry_run.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().accounting_periods().delete_tax_rates(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_tax_rates(&self, id: impl Display) -> Result<()> {
let path = format!("/finance/accountingperiods/{}/taxrates", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get an accounting period
///
/// `GET /finance/accountingperiods/{id}`
///
/// Returns one accounting period visible to the caller through global or group-internal finance permissions. A period rejected by the visibility check returns 403 before it is loaded.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountingperiods-id");
/// let accounting_period = client.finance().accounting_periods().get(1)?;
/// println!("{}", accounting_period.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::AccountingPeriod> {
let path = format!("/finance/accountingperiods/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all accounting periods
///
/// `GET /finance/accountingperiods`
///
/// An accounting period is the date range for one finance client’s books, usually a financial year. Accounts and cost centers belong to a period. Closing a period prevents ordinary account and transaction changes; it is separate from making individual transactions immutable. Returns an unpaginated list of periods visible through global finance permissions or group-internal cost-center rights, ordered by startDate ascending. Finance master-data editors can see all periods. meta.count is the number returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountingperiods");
/// for accounting_period in client.finance().accounting_periods().list()? {
/// println!("{}", accounting_period.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::AccountingPeriod>> {
let path = "/finance/accountingperiods".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get bills for accounting period
///
/// `GET /finance/accountingperiods/{id}/bills`
///
/// Returns a page of supporting documents for an accounting period. Requires permission to view or edit the whole accounting period; access to individual transactions alone is insufficient for this list. Explicit order_by=submittedDate sorts by submission date and then bill ID in the same direction. Without order_by no order is guaranteed. The only supported query parameters are pagination and ordering; submitter/date/text filters are not exposed by this endpoint.
///
/// Use [`Self::list_bills_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountingperiods-id-bills");
/// for bill in client.finance().accounting_periods().list_bills(1)? {
/// println!("{}", bill.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_bills(&self, id: impl Display) -> Result<Vec<models::Bill>> {
self.list_bills_with(id, &Default::default())
}
/// Get bills for accounting period
///
/// Like [`Self::list_bills`], with query parameters.
///
/// `GET /finance/accountingperiods/{id}/bills`
///
/// Returns a page of supporting documents for an accounting period. Requires permission to view or edit the whole accounting period; access to individual transactions alone is insufficient for this list. Explicit order_by=submittedDate sorts by submission date and then bill ID in the same direction. Without order_by no order is guaranteed. The only supported query parameters are pagination and ordering; submitter/date/text filters are not exposed by this endpoint.
pub fn list_bills_with(&self, id: impl Display, query: &GetFinanceAccountingperiodsIdBillsQuery) -> Result<Vec<models::Bill>> {
let path = format!("/finance/accountingperiods/{}/bills", seg(id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get bills for accounting period
///
/// Like [`Self::list_bills_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_bills_iter(&self, id: impl Display, query: &GetFinanceAccountingperiodsIdBillsQuery) -> Items<models::Bill> {
let path = format!("/finance/accountingperiods/{}/bills", seg(id));
self.client.items(&path, query.to_query())
}
/// Get statement suggestion rules
///
/// `GET /finance/accountingperiods/{id}/userrules`
///
/// Returns all suggestion rules for an accounting period, ordered by sortKey ascending, without pagination. Both reading and replacing these rules require edit accounting period permission. meta.count is the number returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountingperiods-id-userrules");
/// for user_rule in client.finance().accounting_periods().list_user_rules(1)? {
/// println!("{}", user_rule.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_user_rules(&self, id: impl Display) -> Result<Vec<models::UserRule>> {
let path = format!("/finance/accountingperiods/{}/userrules", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update accounting period
///
/// `PUT /finance/accountingperiods/{id}`
///
/// Replaces period dates, client, closed state and document-number behavior. Requires finance “edit masterdata”; ordinary edit accounting period permission alone is insufficient. The date/client combination must remain unique. Optionally transfer opening balances or, when closing, make transactions immutable with setImmutability. Reopening does not make transactions editable again. Period settings are saved before these additional actions execute.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountingPeriodUpdate {
/// client_id: 1,
/// end_date: "2026-12-31".parse()?,
/// increment_document_number: true,
/// is_closed: false,
/// start_date: "2026-01-01".parse()?,
/// ..Default::default()
/// };
/// let result = client.finance().accounting_periods().update(1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::AccountingPeriodUpdate) -> Result<models::AccountingPeriod> {
let path = format!("/finance/accountingperiods/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
/// Replace statement suggestion rules
///
/// `PUT /finance/accountingperiods/{id}/userrules`
///
/// Replaces the entire rule set for an accounting period and returns the new records ordered by sortKey. Send rules: \[\] to remove all rules. Existing IDs are discarded and newly inserted rules receive new IDs. Requires edit accounting period permission. This saves rules only; it does not regenerate existing movement suggestions. Deletion and insertion are not enclosed in a single transaction.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::UserRulesUpdate {
/// rules: vec![models::UserRuleCreate {
/// account_ids: vec![5],
/// all_accounts: false,
/// is_income: true,
/// operator: "contains".into(),
/// search_string: "Donation".into(),
/// search_type: "purpose".into(),
/// sort_key: 0,
/// suggestion_type: "costCenterId".into(),
/// suggestion_value: "8".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// for accounting_period in client.finance().accounting_periods().update_user_rules(1, &body)? {
/// println!("{}", accounting_period.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn update_user_rules(&self, id: impl Display, body: &models::UserRulesUpdate) -> Result<Vec<models::UserRule>> {
let path = format!("/finance/accountingperiods/{}/userrules", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().accounting_periods().accounts()`
#[derive(Clone, Copy)]
pub struct FinanceAccountingPeriodsAccountsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceAccountingPeriodsAccountsResource<'a> {
pub fn statements(&self) -> FinanceAccountingPeriodsAccountsStatementsResource<'a> {
FinanceAccountingPeriodsAccountsStatementsResource { client: self.client }
}
/// Delete accounts for accounting period
///
/// `DELETE /finance/accountingperiods/{id}/accounts`
///
/// Deletes all accounts of one accounting period. Requires finance “edit masterdata”. Existing transactions using any of these accounts as account or contra account prevent deletion with HTTP 400. The service removes associated bank statements and transaction purposes, clears account tax-rate links and deletes the period’s tax rates before deleting the accounts in a transaction. This endpoint does not support dry_run. It does not require the period to exist or be open.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().accounting_periods().accounts().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
let path = format!("/finance/accountingperiods/{}/accounts", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get all movements of an account
///
/// `GET /finance/accountingperiods/{id}/accounts/{accountId}/movements`
///
/// Returns a page of imported movements, ordered by documentDate and then numberInStatement ascending. Requires edit accounting period permission for the actual account. Suggestions are always serialized; include\[\]=bills expands their attached documents. The period ID in the URL is not cross-checked against the account.
///
/// Use [`Self::list_movements_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountingperiods-id-accounts-id-movements");
/// for movement in client.finance().accounting_periods().accounts().list_movements(1, 42)? {
/// println!("{}", movement.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_movements(&self, id: impl Display, account_id: impl Display) -> Result<Vec<models::StatementMovement>> {
self.list_movements_with(id, account_id, &Default::default())
}
/// Get all movements of an account
///
/// Like [`Self::list_movements`], with query parameters.
///
/// `GET /finance/accountingperiods/{id}/accounts/{accountId}/movements`
///
/// Returns a page of imported movements, ordered by documentDate and then numberInStatement ascending. Requires edit accounting period permission for the actual account. Suggestions are always serialized; include\[\]=bills expands their attached documents. The period ID in the URL is not cross-checked against the account.
pub fn list_movements_with(&self, id: impl Display, account_id: impl Display, query: &GetFinanceAccountingperiodsIdAccountsIdMovementsQuery) -> Result<Vec<models::StatementMovement>> {
let path = format!("/finance/accountingperiods/{}/accounts/{}/movements", seg(id), seg(account_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all movements of an account
///
/// Like [`Self::list_movements_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_movements_iter(&self, id: impl Display, account_id: impl Display, query: &GetFinanceAccountingperiodsIdAccountsIdMovementsQuery) -> Items<models::StatementMovement> {
let path = format!("/finance/accountingperiods/{}/accounts/{}/movements", seg(id), seg(account_id));
self.client.items(&path, query.to_query())
}
/// Get per-account statement movement statistics
///
/// `GET /finance/accountingperiods/{id}/accounts/statements`
///
/// Returns per-account movement statistics across all imported statements of the accounting period. Only accounts that have at least one statement movement are included. For each account the number of movements is grouped by state (`open`, `booked`, `ignored`); a state key is only present when the account has movements in that state. Requires edit accounting period permission. The response has no outer meta object and no guaranteed account order.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountingperiods-id-accounts-statements");
/// for statement in client.finance().accounting_periods().accounts().list_statements(1)? {
/// println!("{}", statement.account_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_statements(&self, id: impl Display) -> Result<Vec<models::AccountStatementStatistics>> {
let path = format!("/finance/accountingperiods/{}/accounts/statements", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.finance().accounting_periods().accounts().statements()`
#[derive(Clone, Copy)]
pub struct FinanceAccountingPeriodsAccountsStatementsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceAccountingPeriodsAccountsStatementsResource<'a> {
pub fn movements(&self) -> FinanceAccountingPeriodsAccountsStatementsMovementsResource<'a> {
FinanceAccountingPeriodsAccountsStatementsMovementsResource { client: self.client }
}
/// Get imported statements for an account
///
/// `GET /finance/accountingperiods/{id}/accounts/{accountId}/statements`
///
/// Returns all statements for the account, sorted by startDate descending, without pagination. Each statement includes counts for open, booked and ignored movements and their sum. Requires edit accounting period permission. An account outside the path’s accounting period returns HTTP 404.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountingperiods-id-accounts-id-statements");
/// for statement in client.finance().accounting_periods().accounts().statements().list(1, 5)? {
/// println!("{}", statement.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, id: impl Display, account_id: impl Display) -> Result<Vec<models::AccountStatement>> {
let path = format!("/finance/accountingperiods/{}/accounts/{}/statements", seg(id), seg(account_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.finance().accounting_periods().accounts().statements().movements()`
#[derive(Clone, Copy)]
pub struct FinanceAccountingPeriodsAccountsStatementsMovementsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceAccountingPeriodsAccountsStatementsMovementsResource<'a> {
/// Update the state of a movement
///
/// `POST /finance/accountingperiods/{id}/accounts/{accountId}/statements/{statementId}/movements/{movementId}`
///
/// Changes the movement state and returns its associated transaction, or an empty array when none is linked. A transition from any state other than booked to booked creates a new transaction from the current suggestions. Required ordinary-booking fields are documentDate, accountId, contraAccountId and amount, plus documentNumber unless automatic numbering is active. Split suggestions create a split booking and return its first non-tax child. Switching to open or ignored does not undo the existing transaction; booking again can create another transaction. Requires edit accounting period permission for the movement’s actual period; parent IDs in the URL are not cross-checked.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::StatementMovementUpdate {
/// state: "booked".into(),
/// ..Default::default()
/// };
/// let result = client.finance().accounting_periods().accounts().statements().movements().create(1, 42, 7, 123, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, id: impl Display, account_id: impl Display, statement_id: impl Display, movement_id: impl Display, body: &models::StatementMovementUpdate) -> Result<serde_json::Value> {
let path = format!("/finance/accountingperiods/{}/accounts/{}/statements/{}/movements/{}", seg(id), seg(account_id), seg(statement_id), seg(movement_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get all movements of a statement
///
/// `GET /finance/accountingperiods/{id}/accounts/{accountId}/statements/{statementId}/movements`
///
/// Returns a page of imported movements, ordered by documentDate and then numberInStatement ascending. Requires edit accounting period permission for the actual account. Suggestions are always serialized; include\[\]=bills expands their attached documents. The statement must belong to the URL period (otherwise HTTP 404); the URL accountId is not cross-checked.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accountingperiods-id-accounts-id-statements-id-movements");
/// for movement in client.finance().accounting_periods().accounts().statements().movements().list(1, 42, 7)? {
/// println!("{}", movement.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, id: impl Display, account_id: impl Display, statement_id: impl Display) -> Result<Vec<models::StatementMovement>> {
self.list_with(id, account_id, statement_id, &Default::default())
}
/// Get all movements of a statement
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /finance/accountingperiods/{id}/accounts/{accountId}/statements/{statementId}/movements`
///
/// Returns a page of imported movements, ordered by documentDate and then numberInStatement ascending. Requires edit accounting period permission for the actual account. Suggestions are always serialized; include\[\]=bills expands their attached documents. The statement must belong to the URL period (otherwise HTTP 404); the URL accountId is not cross-checked.
pub fn list_with(&self, id: impl Display, account_id: impl Display, statement_id: impl Display, query: &GetFinanceAccountingperiodsIdAccountsIdStatementsIdMovementsQuery) -> Result<Vec<models::StatementMovement>> {
let path = format!("/finance/accountingperiods/{}/accounts/{}/statements/{}/movements", seg(id), seg(account_id), seg(statement_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all movements of a statement
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, id: impl Display, account_id: impl Display, statement_id: impl Display, query: &GetFinanceAccountingperiodsIdAccountsIdStatementsIdMovementsQuery) -> Items<models::StatementMovement> {
let path = format!("/finance/accountingperiods/{}/accounts/{}/statements/{}/movements", seg(id), seg(account_id), seg(statement_id));
self.client.items(&path, query.to_query())
}
/// Update movement suggestions
///
/// `PATCH /finance/accountingperiods/{id}/accounts/{accountId}/statements/{statementId}/movements/{movementId}/suggestions`
///
/// Applies incremental edits to a movement’s booking suggestions. Matches existing fields by name and splitKey. Non-empty values create or change a suggestion; an empty string removes it. Other suggestions are retained. Modified values receive confidence 100 and userOverwrite=true. Repeating an identical value leaves metadata unchanged. Requires edit accounting period permission for the movement’s actual period. Parent IDs in the URL are not cross-checked. Split keys require the split-booking feature.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::MovementSuggestionsUpdate {
/// suggestions: vec![models::MovementSuggestionUpdate {
/// name: "costCenterId".into(),
/// value: "8".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// client.finance().accounting_periods().accounts().statements().movements().patch_suggestions(1, 7, 7, 7, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn patch_suggestions(&self, id: impl Display, account_id: impl Display, statement_id: impl Display, movement_id: impl Display, body: &models::MovementSuggestionsUpdate) -> Result<()> {
let path = format!("/finance/accountingperiods/{}/accounts/{}/statements/{}/movements/{}/suggestions", seg(id), seg(account_id), seg(statement_id), seg(movement_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Patch, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.finance().accounting_periods().statements()`
#[derive(Clone, Copy)]
pub struct FinanceAccountingPeriodsStatementsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceAccountingPeriodsStatementsResource<'a> {
/// Delete a statement
///
/// `DELETE /finance/accountingperiods/{id}/statements/{statementId}`
///
/// Deletes an imported statement, its movements, suggestions and source file. Finance transactions already created from the movements remain. Bills linked to deleted suggestions are also deleted. Requires edit accounting period permission for the statement’s actual period; the period ID in the URL is not cross-checked. There is no dry-run mode.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().accounting_periods().statements().delete(1, 1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display, statement_id: impl Display) -> Result<()> {
let path = format!("/finance/accountingperiods/{}/statements/{}", seg(id), seg(statement_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Preview an uploaded bank statement file
///
/// `POST /finance/accountingperiods/{id}/statements`
///
/// Parses the first uploaded bank statement file and returns a preview without importing it. Send the file in multipart field files\[\]. Supported formats are MT940, CAMT and PayPal CSV; a ZIP can combine top-level files of the same type and account identifier. Requires edit accounting period permission for the path ID. Duplicate comparison is currently performed across all stored accounts in the date range, so the counts can differ from a later account-specific import. To import, upload the file to /files/statement/{accountId}.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let file = Upload::from_path("kontoauszug.xml")?;
/// let statement = client.finance().accounting_periods().statements().preview(1, &[file])?;
/// println!("{}", statement.duplicates);
/// # Ok(())
/// # }
/// ```
pub fn preview(&self, id: impl Display, files: &[Upload]) -> Result<models::AccountStatementPreview> {
let path = format!("/finance/accountingperiods/{}/statements", seg(id));
let query: Query = Query::new();
let form: Query = Query::new();
let bytes = self.client.request_multipart(Method::Post, &path, &query, &form, "files[]", files)?;
crate::decode_data(&bytes)
}
/// Generate suggestions for a statement
///
/// `POST /finance/accountingperiods/{id}/statements/{statementId}/suggestions`
///
/// Runs the configured suggestion generators over every movement of the statement, including movements already booked or ignored. New suggestions are merged with existing ones by field name and split key; an existing suggestion is replaced only by a higher-confidence suggestion, so this is not a complete reset. Invalid account references are removed afterwards. Requires edit accounting period permission for the statement’s actual period. The period ID in the URL is not cross-checked. Returns HTTP 204 without a body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().accounting_periods().statements().suggestions(1, 7)?;
/// # Ok(())
/// # }
/// ```
pub fn suggestions(&self, id: impl Display, statement_id: impl Display) -> Result<()> {
let path = format!("/finance/accountingperiods/{}/statements/{}/suggestions", seg(id), seg(statement_id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Rename a statement
///
/// `PUT /finance/accountingperiods/{id}/statements/{statementId}`
///
/// Renames an imported statement and returns HTTP 204 without a body. Requires edit accounting period permission for the statement’s actual period. The period ID in the URL is not cross-checked by this operation.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountStatementUpdate {
/// name: "September 2026".into(),
/// ..Default::default()
/// };
/// client.finance().accounting_periods().statements().update(1, 1, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, statement_id: impl Display, body: &models::AccountStatementUpdate) -> Result<()> {
let path = format!("/finance/accountingperiods/{}/statements/{}", seg(id), seg(statement_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.finance().accounts()`
#[derive(Clone, Copy)]
pub struct FinanceAccountsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceAccountsResource<'a> {
/// Create or replace accounts in bulk
///
/// `POST /finance/accounts/bulkcreate`
///
/// Imports a JSON array of account definitions. Requires finance “edit masterdata”. Existing accounts are matched by account number and accounting period and updated; other entries are created. Optional fields use the same false/null defaults as single creation, also when replacing existing accounts. Repeated raw period/number pairs in the request collapse to the last entry. Returns HTTP 200 and meta.count for the processed entries. Every affected period must be open. The bulk path does not apply the single-update donation-account protection.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: Vec<models::AccountCreate> = vec![models::AccountCreate {
/// account_group_id: 4,
/// name: "Donations".into(),
/// number: "8200".into(),
/// accounting_period_id: 5,
/// ..Default::default()
/// }];
/// for account in client.finance().accounts().bulk_create(&body)? {
/// println!("{}", account.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn bulk_create(&self, body: &Vec<models::AccountCreate>) -> Result<Vec<models::Account>> {
let path = "/finance/accounts/bulkcreate".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Create new account
///
/// `POST /finance/accounts`
///
/// Creates a ledger account in an open accounting period. Requires finance “edit masterdata”. Name and number must each be unique in that period; account number 9999 is reserved. Returns HTTP 200 with the new account, initially with balance 0.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountCreate {
/// account_group_id: 4,
/// name: "Donations".into(),
/// number: "8200".into(),
/// accounting_period_id: 5,
/// ..Default::default()
/// };
/// let result = client.finance().accounts().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::AccountCreate) -> Result<models::Account> {
let path = "/finance/accounts".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete account
///
/// `DELETE /finance/accounts/{id}`
///
/// Deletes an account if no transactions, transaction purposes, tax rates or cash discounts require it. Requires finance “edit masterdata”. Associated bank statements, account movements and transaction suggestions are removed. dry_run=true returns the HTTP 409 conflict report without deleting, including when deletion is allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().accounts().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete account
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/accounts/{id}`
///
/// Deletes an account if no transactions, transaction purposes, tax rates or cash discounts require it. Requires finance “edit masterdata”. Associated bank statements, account movements and transaction suggestions are removed. dry_run=true returns the HTTP 409 conflict report without deleting, including when deletion is allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceAccountsIdQuery) -> Result<()> {
let path = format!("/finance/accounts/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Download an account-import workbook
///
/// `POST /finance/accounts/exporttemplate`
///
/// Downloads an XLSX workbook with translated column headings and import instructions. Requires finance “edit masterdata”. Select a finance template, existing accounts by year and optional client, or omit the selection for an empty workbook. Only accounting periods visible to the caller contribute existing accounts.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountImportTemplateCreate {
/// client_id: Some(Some(1)),
/// ..Default::default()
/// };
/// let data = client.finance().accounts().export_template(&body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn export_template(&self, body: &models::AccountImportTemplateCreate) -> Result<Vec<u8>> {
let path = "/finance/accounts/exporttemplate".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
/// Get an account
///
/// `GET /finance/accounts/{id}`
///
/// Returns one visible ledger account with calculated balances, preceding-period budget values and posting permission. Visibility follows the same rules as the collection endpoint. An unknown ID returns 404; an existing but inaccessible account returns 403.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accounts-id");
/// let account = client.finance().accounts().get(1)?;
/// println!("{}", account.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::Account> {
let path = format!("/finance/accounts/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Export accounts as CSV
///
/// `GET /finance/accounts/csv`
///
/// Downloads visible accounts of one accounting period. Requires global finance “view accounting period” for that period. Columns contain number, name, annotation, budget, account-group name, account function, tax type/rate and identifier. Headings use the installation language. Budgets use formatted major currency units. CSV uses semicolons and a UTF-8 BOM. Returns an attachment without a JSON wrapper.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetFinanceAccountsCsvQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let data = client.finance().accounts().get_csv(&query)?;
/// std::fs::write("ergebnis.csv", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_csv(&self, query: &GetFinanceAccountsCsvQuery) -> Result<Vec<u8>> {
let path = "/finance/accounts/csv".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Export accounts
///
/// `GET /finance/accounts/export`
///
/// Downloads visible accounts of one accounting period. Requires global finance “view accounting period” for that period. Columns contain number, name, annotation, budget, account-group name, account function, tax type/rate and identifier. Headings use the installation language. Budgets use formatted major currency units. CSV uses semicolons and a UTF-8 BOM. Returns an attachment without a JSON wrapper.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetFinanceAccountsExportQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let data = client.finance().accounts().get_export(&query)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_export(&self, query: &GetFinanceAccountsExportQuery) -> Result<Vec<u8>> {
let path = "/finance/accounts/export".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Get visible accounts
///
/// `GET /finance/accounts`
///
/// A ledger account belongs to one accounting period and one account group. The group links it to an account class and account type. Transactions post amounts between an account and a contra account. Amounts and budgets use integer minor currency units, for example cents. Returns an unpaginated list filtered by finance master-data permission, accounting-period permissions or access through cost centers and transaction purposes. Accounts are sorted by number across all selected periods, without a separate period sort. meta.count is the number returned. Balances and preceding-period budgets are calculated by default.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-accounts");
/// for account in client.finance().accounts().list()? {
/// println!("{}", account.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Account>> {
self.list_with(&Default::default())
}
/// Get visible accounts
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /finance/accounts`
///
/// A ledger account belongs to one accounting period and one account group. The group links it to an account class and account type. Transactions post amounts between an account and a contra account. Amounts and budgets use integer minor currency units, for example cents. Returns an unpaginated list filtered by finance master-data permission, accounting-period permissions or access through cost centers and transaction purposes. Accounts are sorted by number across all selected periods, without a separate period sort. meta.count is the number returned. Balances and preceding-period budgets are calculated by default.
pub fn list_with(&self, query: &GetFinanceAccountsQuery) -> Result<Vec<models::Account>> {
let path = "/finance/accounts".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update account
///
/// `PUT /finance/accounts/{id}`
///
/// Replacement values for an account in an open accounting period. The period cannot be changed here. Omitted optional fields reset to false or null. A donation account with existing donation transactions cannot have isDonationAccount disabled through this single-update endpoint. Requires finance “edit masterdata”. Returns recalculated balances and posting permission. isMandatoryEubpLocked cannot be changed by this operation.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountUpdate {
/// account_group_id: 4,
/// name: "Donations".into(),
/// number: "8200".into(),
/// ..Default::default()
/// };
/// let result = client.finance().accounts().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::AccountUpdate) -> Result<models::Account> {
let path = format!("/finance/accounts/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().bills()`
#[derive(Clone, Copy)]
pub struct FinanceBillsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceBillsResource<'a> {
/// Create new bill
///
/// `POST /finance/bills`
///
/// Registers an existing uploaded file as a supporting document. Exactly one booking link is required. The linked transaction, all split components, or the account movement behind a suggestion must belong to accountingPeriodId. Ordinary and split transactions must be mutable and pass booking authorization. The submitting person must be visible. Returns the stored bill including file download metadata.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = serde_json::json!({
/// "accountingPeriodId": 1,
/// "fileId": 21,
/// "submittedDate": "2026-09-14",
/// "submittedPid": 42,
/// "transactionId": 12
/// });
/// let result = client.finance().bills().create(&body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &serde_json::Value) -> Result<models::Bill> {
let path = "/finance/bills".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete bill
///
/// `DELETE /finance/bills/{id}`
///
/// Deletes a supporting document and its attached file, leaving the booking itself intact. Requires bill-update permissions and validates the existing booking links; immutable ordinary transactions or split components prevent deletion. dry_run=true performs the same checks and returns HTTP 409 with deletion information without deleting.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().bills().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete bill
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/bills/{id}`
///
/// Deletes a supporting document and its attached file, leaving the booking itself intact. Requires bill-update permissions and validates the existing booking links; immutable ordinary transactions or split components prevent deletion. dry_run=true performs the same checks and returns HTTP 409 with deletion information without deleting.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceBillsIdQuery) -> Result<()> {
let path = format!("/finance/bills/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a bill
///
/// `GET /finance/bills/{id}`
///
/// Returns one supporting document. Access is granted through view/edit permission for its accounting period or visibility of its directly linked ordinary transaction. Split transactions and booking suggestions do not provide this additional individual-access route.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-bills-id");
/// let bill = client.finance().bills().get(1)?;
/// println!("{}", bill.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::Bill> {
let path = format!("/finance/bills/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update bill
///
/// `PUT /finance/bills/{id}`
///
/// Updates submission date/person and optionally renames the file or changes its booking link. Requires edit permission for the accounting period or update access to the directly linked ordinary transaction. A directly linked immutable transaction prevents changes. Newly supplied transaction/split links are checked for authorization, immutability and accounting-period consistency. Omitted or null link IDs do not detach the document. Accounting period and file attachment remain fixed.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::BillUpdate {
/// submitted_date: "2026-09-14".parse()?,
/// submitted_pid: 42,
/// ..Default::default()
/// };
/// let result = client.finance().bills().update(1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::BillUpdate) -> Result<models::Bill> {
let path = format!("/finance/bills/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().cash_discounts()`
#[derive(Clone, Copy)]
pub struct FinanceCashDiscountsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceCashDiscountsResource<'a> {
/// Create a cash discount
///
/// `POST /finance/cashdiscounts`
///
/// A cash discount defines a percentage for early-payment discounts and the ledger account to which the discount is posted. Its accounting period is determined by that account. Requires finance “edit masterdata”. Returns HTTP 200 on success.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::CashDiscountCreate {
/// account_id: 5,
/// note: "Skonto 2%".into(),
/// rate: 2,
/// ..Default::default()
/// };
/// let result = client.finance().cash_discounts().create(&body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::CashDiscountCreate) -> Result<models::CashDiscount> {
let path = "/finance/cashdiscounts".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete cash discount
///
/// `DELETE /finance/cashdiscounts/{id}`
///
/// Deletes this cash discount if no transactions reference it. Requires finance “edit masterdata”. dry_run=true returns the HTTP 409 conflict report without deleting, also when deletion is allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().cash_discounts().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete cash discount
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/cashdiscounts/{id}`
///
/// Deletes this cash discount if no transactions reference it. Requires finance “edit masterdata”. dry_run=true returns the HTTP 409 conflict report without deleting, also when deletion is allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceCashdiscountsIdQuery) -> Result<()> {
let path = format!("/finance/cashdiscounts/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a cash discount
///
/// `GET /finance/cashdiscounts/{id}`
///
/// A cash discount defines a percentage for early-payment discounts and the ledger account to which the discount is posted. Its accounting period is determined by that account. Returns one definition by ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-cashdiscounts-id");
/// let cash_discount = client.finance().cash_discounts().get(1)?;
/// println!("{}", cash_discount.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::CashDiscount> {
let path = format!("/finance/cashdiscounts/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all cash discounts
///
/// `GET /finance/cashdiscounts`
///
/// A cash discount defines a percentage for early-payment discounts and the ledger account to which the discount is posted. Its accounting period is determined by that account. Returns an unpaginated list. Optionally restrict results to the linked accounts’ accounting period. No result order is guaranteed; an unknown period returns an empty list. meta.count is the number returned.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-cashdiscounts");
/// for cash_discount in client.finance().cash_discounts().list()? {
/// println!("{}", cash_discount.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::CashDiscount>> {
self.list_with(&Default::default())
}
/// Get all cash discounts
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /finance/cashdiscounts`
///
/// A cash discount defines a percentage for early-payment discounts and the ledger account to which the discount is posted. Its accounting period is determined by that account. Returns an unpaginated list. Optionally restrict results to the linked accounts’ accounting period. No result order is guaranteed; an unknown period returns an empty list. meta.count is the number returned.
pub fn list_with(&self, query: &GetFinanceCashdiscountsQuery) -> Result<Vec<models::CashDiscount>> {
let path = "/finance/cashdiscounts".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update cash discount
///
/// `PUT /finance/cashdiscounts/{id}`
///
/// Replaces this cash discount. Requires finance “edit masterdata”. All required creation fields must be supplied again.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::CashDiscountUpdate {
/// account_id: 5,
/// note: "Skonto 2%".into(),
/// rate: 2,
/// ..Default::default()
/// };
/// let result = client.finance().cash_discounts().update(1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::CashDiscountUpdate) -> Result<models::CashDiscount> {
let path = format!("/finance/cashdiscounts/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().clients()`
#[derive(Clone, Copy)]
pub struct FinanceClientsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceClientsResource<'a> {
/// Create new client
///
/// `POST /finance/clients`
///
/// Creates a finance client. Requires finance “edit masterdata” and an available client slot in the installation license. Returns HTTP 201 with the treasurer expanded, if assigned. Optional fields default to null.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ClientCreate {
/// name: "Example congregation".into(),
/// sort_key: 0,
/// ..Default::default()
/// };
/// let result = client.finance().clients().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ClientCreate) -> Result<models::Client> {
let path = "/finance/clients".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete client
///
/// `DELETE /finance/clients/{id}`
///
/// Deletes a finance client if no accounting periods reference it. Requires finance “edit masterdata”. With dry_run=true no deletion occurs and HTTP 409 returns the conflict report, also when deletion would be allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().clients().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete client
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/clients/{id}`
///
/// Deletes a finance client if no accounting periods reference it. Requires finance “edit masterdata”. With dry_run=true no deletion occurs and HTTP 409 returns the conflict report, also when deletion would be allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceClientsIdQuery) -> Result<()> {
let path = format!("/finance/clients/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a client
///
/// `GET /finance/clients/{id}`
///
/// Returns a finance client visible under the same rules as the collection endpoint. An unknown or invisible client returns 404. A finance client is the organizational entity whose books are kept separately, for example a congregation or a charitable organization. Each client owns accounting periods, and those periods own its accounts and cost centers. It is unrelated to an OAuth application client.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-clients-id");
/// let item = client.finance().clients().get(1)?;
/// println!("{}", item.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::Client> {
let path = format!("/finance/clients/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all clients
///
/// `GET /finance/clients`
///
/// A finance client is the organizational entity whose books are kept separately, for example a congregation or a charitable organization. Each client owns accounting periods, and those periods own its accounts and cost centers. It is unrelated to an OAuth application client. Returns an unpaginated list ordered by sortKey. Users with finance “edit masterdata” see all clients; other callers see clients belonging to their visible accounting periods. meta.count is the number returned. The treasurer is expanded to a person domain object.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-clients");
/// for item in client.finance().clients().list()? {
/// println!("{}", item.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Client>> {
let path = "/finance/clients".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update client
///
/// `PUT /finance/clients/{id}`
///
/// Replacement finance-client data. name and sortKey are required; omitted optional fields are cleared, including contact, DATEV and euBP fields. Requires finance “edit masterdata”. The client name must remain unique.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ClientUpdate {
/// name: "Example congregation".into(),
/// sort_key: 0,
/// ..Default::default()
/// };
/// let result = client.finance().clients().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::ClientUpdate) -> Result<models::Client> {
let path = format!("/finance/clients/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().cost_centers()`
#[derive(Clone, Copy)]
pub struct FinanceCostCentersResource<'a> {
client: &'a Client,
}
impl<'a> FinanceCostCentersResource<'a> {
/// Import many cost centers
///
/// `POST /finance/costcenters/bulkcreate`
///
/// Creates cost centers in one database transaction and returns HTTP 201. Requires finance “edit masterdata”; every target period must exist and be open. Each item uses the creation fields, including optional annotation. The bulk controller does not run the single-create uniqueness constraint. Results contain stored entities without the expanded group property. meta.count is the number created.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::CostCenterBulkCreate {
/// cost_centers: vec![models::CostCenterCreate {
/// accounting_period_id: 1,
/// name: "Kostenstelle Sonstige".into(),
/// number: "802".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// for cost_center in client.finance().cost_centers().bulk_create(&body)? {
/// println!("{:?}", cost_center.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn bulk_create(&self, body: &models::CostCenterBulkCreate) -> Result<Vec<models::CostCenterStored>> {
let path = "/finance/costcenters/bulkcreate".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Create new cost center
///
/// `POST /finance/costcenters`
///
/// Creates a cost center. A cost center assigns income and expenses to a purpose, project or group within one accounting period. Budgets and balances use integer minor currency units (for example cents). Linking a group also enables access through group-internal finance permissions. Requires finance “edit masterdata” and an open accounting period. Name and number must each be unique in that period. Returns HTTP 200. budgetBalance initially equals budget; spent and previous-period values are not yet calculated.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::CostCenterCreate {
/// accounting_period_id: 1,
/// name: "Kostenstelle Sonstige".into(),
/// number: "802".into(),
/// ..Default::default()
/// };
/// let result = client.finance().cost_centers().create(&body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::CostCenterCreate) -> Result<models::CostCenter> {
let path = "/finance/costcenters".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete cost center
///
/// `DELETE /finance/costcenters/{id}`
///
/// Deletes a cost center if no transactions or transaction purposes reference it. Requires finance “edit masterdata”. Linked transaction suggestions are removed. dry_run=true returns the HTTP 409 report without deleting, including when deletion would be allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().cost_centers().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete cost center
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/costcenters/{id}`
///
/// Deletes a cost center if no transactions or transaction purposes reference it. Requires finance “edit masterdata”. Linked transaction suggestions are removed. dry_run=true returns the HTTP 409 report without deleting, including when deletion would be allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceCostcentersIdQuery) -> Result<()> {
let path = format!("/finance/costcenters/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a cost center
///
/// `GET /finance/costcenters/{id}`
///
/// Returns one visible cost center and its linked group. Visibility follows the same period and group permissions as the collection endpoint. A missing or invisible ID is rejected with 403 before the entity lookup. Budget values may be null when no budget is configured.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-costcenters-id");
/// let cost_center = client.finance().cost_centers().get(1)?;
/// println!("{:?}", cost_center.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::CostCenter> {
let path = format!("/finance/costcenters/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Export cost centers
///
/// `GET /finance/costcenters/export`
///
/// Downloads the visible cost centers of one accounting period as CSV or XLSX. Requires global finance “view accounting period” for the selected period. Columns contain ID, number, name, budget and linked group ID. Headings are translated using the installation language. CSV uses semicolons and a UTF-8 BOM; budgets are formatted as major currency units. The response is a file, without a JSON data wrapper.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetFinanceCostcentersExportQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let data = client.finance().cost_centers().get_export(&query)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_export(&self, query: &GetFinanceCostcentersExportQuery) -> Result<Vec<u8>> {
let path = "/finance/costcenters/export".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Get visible cost centers
///
/// `GET /finance/costcenters`
///
/// A cost center assigns income and expenses to a purpose, project or group within one accounting period. Budgets and balances use integer minor currency units (for example cents). Linking a group also enables access through group-internal finance permissions. Returns an unpaginated list filtered by global accounting-period rights and group-internal permissions to see cost centers, see budgets or post transactions. Sorted by accounting-period ID, then the numeric value of number, ascending. Previous-period budget values are matched by cost-center number. meta.count is the number returned.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-costcenters");
/// for cost_center in client.finance().cost_centers().list()? {
/// println!("{:?}", cost_center.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::CostCenter>> {
self.list_with(&Default::default())
}
/// Get visible cost centers
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /finance/costcenters`
///
/// A cost center assigns income and expenses to a purpose, project or group within one accounting period. Budgets and balances use integer minor currency units (for example cents). Linking a group also enables access through group-internal finance permissions. Returns an unpaginated list filtered by global accounting-period rights and group-internal permissions to see cost centers, see budgets or post transactions. Sorted by accounting-period ID, then the numeric value of number, ascending. Previous-period budget values are matched by cost-center number. meta.count is the number returned.
pub fn list_with(&self, query: &GetFinanceCostcentersQuery) -> Result<Vec<models::CostCenter>> {
let path = "/finance/costcenters".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update cost center
///
/// `PUT /finance/costcenters/{id}`
///
/// Replacement values for a cost center. number and accountingPeriodId are required; omitted name, annotation, budget and groupId are cleared. The target accounting period must be open. Both name and number must remain unique in that period. Requires finance “edit masterdata”. The returned current-period balance is recalculated; previous-period values are not guaranteed to be refreshed by this update.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::CostCenterUpdate {
/// accounting_period_id: 1,
/// number: "802".into(),
/// ..Default::default()
/// };
/// let result = client.finance().cost_centers().update(1, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::CostCenterUpdate) -> Result<models::CostCenter> {
let path = format!("/finance/costcenters/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().donators()`
#[derive(Clone, Copy)]
pub struct FinanceDonatorsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceDonatorsResource<'a> {
/// Create donation receipts
///
/// `POST /finance/donators/receipts`
///
/// Queues ORIGINAL receipts for all donor households selected through the caller’s visible accounts. Requires accounting-period visibility and valid cover-letter/attachment template identifiers. A period already marked as having generated receipts is rejected. The period is marked when jobs are queued, before they finish. Returns HTTP 202 with job information, or HTTP 200 with total=0 and null job information when there are no households. Poll data.statusUrl before downloading the combined files.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::DonationReceiptsCreate {
/// accounting_period_id: 1,
/// donation_receipt_attachment_template_id: "abc123".into(),
/// donation_receipt_letter_template_id: "abc123".into(),
/// ..Default::default()
/// };
/// let result = client.finance().donators().create_receipts(&body)?;
/// println!("{:?}", result.job_group);
/// # Ok(())
/// # }
/// ```
pub fn create_receipts(&self, body: &models::DonationReceiptsCreate) -> Result<models::DonationReceiptJobResult> {
let path = "/finance/donators/receipts".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Create donation receipt PDFs (cover letter and attachment)
///
/// `POST /finance/donators/{donatorCoupleId}/receipts`
///
/// Generates cover-letter and attachment PDFs using the default templates. DRAFT produces temporary files and is not persisted. If the accounting period has not ended, or batch receipts were generated before its end, the request is forced to DRAFT. Other types are persisted when no stored receipt exists; if one already exists, it is returned with HTTP 200 instead of generating another. Newly generated files return HTTP 201. Requires visibility of the accounting period.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::DonationReceiptCreate {
/// accounting_period_id: 1,
/// ..Default::default()
/// };
/// let result = client.finance().donators().create_receipts_for("42-43", &body)?;
/// println!("{}", result.accounting_period_id);
/// # Ok(())
/// # }
/// ```
pub fn create_receipts_for(&self, donator_couple_id: impl Display, body: &models::DonationReceiptCreate) -> Result<models::DonationReceipt> {
let path = format!("/finance/donators/{}/receipts", seg(donator_couple_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete the latest receipt for a donor
///
/// `DELETE /finance/donators/{donatorCoupleId}/receipts`
///
/// Deletes only the latest stored receipt for the donor or pair, including its two stored files. Older receipts, if present, remain. Requires visibility of the accounting period. No dry-run is supported; the accounting-period batch-generation marker is not reset.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = DeleteFinanceDonatorsDonatorCoupleIdQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// client.finance().donators().delete_latest_receipt_for("42-43", &query)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_latest_receipt_for(&self, donator_couple_id: impl Display, query: &DeleteFinanceDonatorsDonatorCoupleIdQuery) -> Result<()> {
let path = format!("/finance/donators/{}/receipts", seg(donator_couple_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Delete all donation receipts
///
/// `DELETE /finance/donators/receipts`
///
/// Deletes all stored donation receipts and their files for the accounting period, then clears its batch-generation timestamp so generation can be repeated. Requires finance edit masterdata. Active generation jobs prevent deletion. Processing is synchronous, but the endpoint returns HTTP 202 without a body. Each receipt is deleted in its own transaction.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = DeleteFinanceDonatorsReceiptsQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// client.finance().donators().delete_receipts(&query)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_receipts(&self, query: &DeleteFinanceDonatorsReceiptsQuery) -> Result<()> {
let path = "/finance/donators/receipts".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get combined donation receipt PDFs
///
/// `GET /finance/donators/receipts`
///
/// Builds combined PDF download files from stored ORIGINAL receipts for the caller’s visible donor households, sorted by postcode, street, last name and first name. Requires accounting-period visibility. An active receipt job group normally returns HTTP 400; receipts must already exist. twofiles returns separate coverLetters and attachments URLs. onefile returns one coverLetters URL containing each household’s letter and attachment. Early-generated batch receipts receive a DRAFT watermark.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetFinanceDonatorsReceiptsQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let receipt = client.finance().donators().get_receipts(&query)?;
/// println!("{:?}", receipt.attachments);
/// # Ok(())
/// # }
/// ```
pub fn get_receipts(&self, query: &GetFinanceDonatorsReceiptsQuery) -> Result<models::CombinedDonationReceipts> {
let path = "/finance/donators/receipts".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get existing donation receipt PDFs (cover letter and attachment)
///
/// `GET /finance/donators/{donatorCoupleId}/receipts`
///
/// Returns the latest stored receipt for the donor or pair and accounting period. The requested type controls watermarking only; the stored record is selected by creation date regardless of type. DRAFT and DUPLICATE produce temporary watermarked PDFs; ORIGINAL returns the stored files directly. Requires visibility of the accounting period.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetFinanceDonatorsDonatorCoupleIdQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let receipts_for = client.finance().donators().get_receipts_for("42-43", &query)?;
/// println!("{}", receipts_for.accounting_period_id);
/// # Ok(())
/// # }
/// ```
pub fn get_receipts_for(&self, donator_couple_id: impl Display, query: &GetFinanceDonatorsDonatorCoupleIdQuery) -> Result<models::DonationReceipt> {
let path = format!("/finance/donators/{}/receipts", seg(donator_couple_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get donor household donation summaries
///
/// `GET /finance/donators`
///
/// Returns paginated donation/payback aggregates for one accounting period. Both accounts of each contributing transaction must be visible in the period. Requires explicit view or edit access to the complete accounting period; group-only access is insufficient. Completeness and name search use the single donor or the lower-ID person of a pair. meta.incompleteCount counts incomplete households after applying the current filters, before pagination. Ordering has no additional tie-breaker.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-donators");
/// let query = GetFinanceDonatorsQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// for donator in client.finance().donators().list(&query)? {
/// println!("{}", donator.count);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetFinanceDonatorsQuery) -> Result<Vec<models::Donator>> {
let path = "/finance/donators".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get donor household donation summaries
///
/// Like [`Self::list`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetFinanceDonatorsQuery) -> Items<models::Donator> {
let path = "/finance/donators".to_owned();
self.client.items(&path, query.to_query())
}
}
/// `client.finance().eubp()`
#[derive(Clone, Copy)]
pub struct FinanceEubpResource<'a> {
client: &'a Client,
}
impl<'a> FinanceEubpResource<'a> {
pub fn submissions(&self) -> FinanceEubpSubmissionsResource<'a> {
FinanceEubpSubmissionsResource { client: self.client }
}
/// Get euBP service health status
///
/// `GET /finance/eubp/health`
///
/// Checks the configured eXTra integration service and returns its availability, URL and configured environment. A connection failure is represented by extraServiceAvailable=false with HTTP 200. This does not establish that a submission will be accepted by DRV. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-eubp-health");
/// let health = client.finance().eubp().get_health()?;
/// println!("{}", health.environment);
/// # Ok(())
/// # }
/// ```
pub fn get_health(&self) -> Result<models::EubpHealthInfo> {
let path = "/finance/eubp/health".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.finance().eubp().submissions()`
#[derive(Clone, Copy)]
pub struct FinanceEubpSubmissionsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceEubpSubmissionsResource<'a> {
pub fn periods(&self) -> FinanceEubpSubmissionsPeriodsResource<'a> {
FinanceEubpSubmissionsPeriodsResource { client: self.client }
}
/// Cancel euBP submission
///
/// `POST /finance/eubp/submissions/{id}/cancel`
///
/// Sends an external cancellation request and keeps the local submission. Allowed from pending, sent, accepted, rejected and cancelled; a treasurer and business number are required. A successful result sets cancelled. An eXTra-level rejection can still return HTTP 200 with rejection details in the submission, so inspect the returned status codes. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let submission = client.finance().eubp().submissions().cancel(1)?;
/// println!("{:?}", submission.title);
/// # Ok(())
/// # }
/// ```
pub fn cancel(&self, id: impl Display) -> Result<models::EubpSubmission> {
let path = format!("/finance/eubp/submissions/{}/cancel", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Create new euBP submission
///
/// `POST /finance/eubp/submissions`
///
/// Creates a draft euBP submission for the inclusive calendar-year range. Main-client treasurer and business number are required. The main client is always included; eligible additional clients receive their own period rows. Each year links the first overlapping CT accounting period, or remains a row without data. Company name/number are snapshotted. No transmission is sent by this endpoint; a delivery deadline within seven days can trigger a notification. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EubpSubmissionCreate {
/// client_id: 1,
/// transmission_reason: 1,
/// year_from: 2020,
/// year_to: 2023,
/// ..Default::default()
/// };
/// let result = client.finance().eubp().submissions().create(&body)?;
/// println!("{:?}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::EubpSubmissionCreate) -> Result<models::EubpSubmission> {
let path = "/finance/eubp/submissions".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete euBP submission
///
/// `DELETE /finance/eubp/submissions/{id}`
///
/// Deletes the local submission. For every state other than draft, it first sends an external cancellation request and requires a configured treasurer and business number. There is no dry-run mode. This is different from cancel, which retains the local record. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().eubp().submissions().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
let path = format!("/finance/eubp/submissions/{}", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Fetch status from DRV for euBP submission
///
/// `POST /finance/eubp/submissions/{id}/fetch-status`
///
/// Fetches remote responses through eXTra, applies status/results locally and confirms received response IDs. Allowed from draft, pending, sent, accepted, rejected and cancelled. This operation can update the stored workflow state and history; it is not just a local read. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let submission = client.finance().eubp().submissions().fetch_status(1)?;
/// println!("{:?}", submission.title);
/// # Ok(())
/// # }
/// ```
pub fn fetch_status(&self, id: impl Display) -> Result<models::EubpSubmission> {
let path = format!("/finance/eubp/submissions/{}/fetch-status", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Mark euBP submission as finished
///
/// `POST /finance/eubp/submissions/{id}/finish`
///
/// Locally marks an accepted submission as finished and records the change in history. Other starting states return HTTP 400. Does not send another transmission. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// let submission = client.finance().eubp().submissions().finish(1, &body)?;
/// println!("{:?}", submission.title);
/// # Ok(())
/// # }
/// ```
pub fn finish(&self, id: impl Display, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<models::EubpSubmission> {
let path = format!("/finance/eubp/submissions/{}/finish", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Generate euBP export files
///
/// `POST /finance/eubp/submissions/{id}/generate`
///
/// Generates and stores a new ZIP of transmission files and returns its download URL. This updates fileId/downloadUrl but neither sends data nor changes the workflow status. Requires the main client’s treasurer and a business number. File numbers are simulated without reserving transmission numbers. This operation is permitted in any submission state. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let submission = client.finance().eubp().submissions().generate(1)?;
/// println!("{}", submission.download_url);
/// # Ok(())
/// # }
/// ```
pub fn generate(&self, id: impl Display) -> Result<models::PostFinanceEubpSubmissionsIdGenerateData> {
let path = format!("/finance/eubp/submissions/{}/generate", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Get euBP submission by ID
///
/// `GET /finance/eubp/submissions/{id}`
///
/// Returns the stored submission, including all client/year rows and the most recent transmission statuses. This does not contact DRV to refresh the status. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-eubp-submissions-id");
/// let submission = client.finance().eubp().submissions().get(1)?;
/// println!("{:?}", submission.title);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::EubpSubmission> {
let path = format!("/finance/eubp/submissions/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get preview data for euBP submission
///
/// `GET /finance/eubp/submissions/{id}/preview`
///
/// Returns date ranges for all client/year rows and informational warnings for missing accounting periods. It does not generate an export or contact DRV. Multiple clients can produce repeated year entries; preview rows currently contain no client ID. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-eubp-submissions-id-preview");
/// let preview = client.finance().eubp().submissions().get_preview(1)?;
/// println!("{:?}", preview);
/// # Ok(())
/// # }
/// ```
pub fn get_preview(&self, id: impl Display) -> Result<models::EubpSubmissionPreview> {
let path = format!("/finance/eubp/submissions/{}/preview", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all euBP submissions
///
/// `GET /finance/eubp/submissions`
///
/// Returns all audit submissions, newest ID first, without pagination. client_id matches the main client or any client represented by a submission-period row. An unknown client filter returns an empty list. meta.count is the number returned. Requires finance edit masterdata permission.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-eubp-submissions");
/// for submission in client.finance().eubp().submissions().list()? {
/// println!("{:?}", submission.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::EubpSubmission>> {
self.list_with(&Default::default())
}
/// Get all euBP submissions
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /finance/eubp/submissions`
///
/// Returns all audit submissions, newest ID first, without pagination. client_id matches the main client or any client represented by a submission-period row. An unknown client filter returns an empty list. meta.count is the number returned. Requires finance edit masterdata permission.
pub fn list_with(&self, query: &GetFinanceEubpSubmissionsQuery) -> Result<Vec<models::EubpSubmission>> {
let path = "/finance/eubp/submissions".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get unified accounts for euBP submission
///
/// `GET /finance/eubp/submissions/{id}/accounts`
///
/// Returns accounts with bookings across the submission’s linked accounting periods, merged by exact number|name. Optional client_id restricts the contributing client. Accounts are sorted by account-number length and then lexicographically; years are sorted ascending. This response has no meta wrapper. Requires finance edit masterdata permission.
///
/// Use [`Self::list_accounts_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-eubp-submissions-id-accounts");
/// for account in client.finance().eubp().submissions().list_accounts(1)? {
/// println!("{}", account.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_accounts(&self, id: impl Display) -> Result<Vec<models::EubpUnifiedAccount>> {
self.list_accounts_with(id, &Default::default())
}
/// Get unified accounts for euBP submission
///
/// Like [`Self::list_accounts`], with query parameters.
///
/// `GET /finance/eubp/submissions/{id}/accounts`
///
/// Returns accounts with bookings across the submission’s linked accounting periods, merged by exact number|name. Optional client_id restricts the contributing client. Accounts are sorted by account-number length and then lexicographically; years are sorted ascending. This response has no meta wrapper. Requires finance edit masterdata permission.
pub fn list_accounts_with(&self, id: impl Display, query: &GetFinanceEubpSubmissionsIdAccountsQuery) -> Result<Vec<models::EubpUnifiedAccount>> {
let path = format!("/finance/eubp/submissions/{}/accounts", seg(id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Reopen finished euBP submission
///
/// `POST /finance/eubp/submissions/{id}/reopen`
///
/// Locally changes finished back to accepted and records the change in history. Other starting states return HTTP 400. This does not make the account selection editable, because accepted is not an editable state. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// let submission = client.finance().eubp().submissions().reopen(1, &body)?;
/// println!("{:?}", submission.title);
/// # Ok(())
/// # }
/// ```
pub fn reopen(&self, id: impl Display, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<models::EubpSubmission> {
let path = format!("/finance/eubp/submissions/{}/reopen", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Send euBP submission to DRV
///
/// `POST /finance/eubp/submissions/{id}/send`
///
/// Queues transmission through the eXTra service and returns HTTP 202 with the current submission. Allowed from draft, rejected, response, sent and accepted. Requires a treasurer and business number. The submission is set to pending and old status codes are cleared before the background job is queued. HTTP 202 does not confirm DRV acceptance; read or refresh status afterwards. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().eubp().submissions().send(1)?;
/// # Ok(())
/// # }
/// ```
pub fn send(&self, id: impl Display) -> Result<()> {
let path = format!("/finance/eubp/submissions/{}/send", seg(id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Update accounts for euBP submission
///
/// `PUT /finance/eubp/submissions/{id}/accounts`
///
/// Replaces the optional account selections across linked periods, optionally for one client. Uses exact number|name keys. Unknown keys are ignored and omitted optional selections are removed. Mandatory accounts are not stored as additional selections. Only draft, rejected and response are editable. Returns the resulting merged list of accounts with bookings, without meta. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EubpSubmissionAccountsUpdate {
/// account_keys: vec!["1200|Bank".into()],
/// ..Default::default()
/// };
/// for submission in client.finance().eubp().submissions().update_accounts(1, &body)? {
/// println!("{}", submission.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn update_accounts(&self, id: impl Display, body: &models::EubpSubmissionAccountsUpdate) -> Result<Vec<models::EubpUnifiedAccount>> {
let path = format!("/finance/eubp/submissions/{}/accounts", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().eubp().submissions().periods()`
#[derive(Clone, Copy)]
pub struct FinanceEubpSubmissionsPeriodsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceEubpSubmissionsPeriodsResource<'a> {
/// Update additional accounts for a submission period
///
/// `PUT /finance/eubp/submissions/{id}/periods/{periodId}/accounts`
///
/// Replaces the additional-account selection for one submission-period row. periodId is a row ID from submission.periods, not an accounting-period ID. A row belonging to another submission returns HTTP 400. Only draft, rejected and response are editable. Unknown account IDs are ignored; current code does not enforce that supplied accounts belong to the row’s accounting period. Requires finance edit masterdata permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::EubpPeriodAccountsUpdate {
/// account_ids: vec![10, 11],
/// ..Default::default()
/// };
/// let result = client.finance().eubp().submissions().periods().update_accounts(1, 1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update_accounts(&self, id: impl Display, period_id: impl Display, body: &models::EubpPeriodAccountsUpdate) -> Result<models::EubpSubmissionPeriod> {
let path = format!("/finance/eubp/submissions/{}/periods/{}/accounts", seg(id), seg(period_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().reports()`
#[derive(Clone, Copy)]
pub struct FinanceReportsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceReportsResource<'a> {
pub fn statement(&self) -> FinanceReportsStatementResource<'a> {
FinanceReportsStatementResource { client: self.client }
}
/// Create balance report
///
/// `POST /finance/reports/balance`
///
/// Creates a balance sheet from balance accounts in the requested document-date range. The configured profit/loss account class can include the period result. Requires finance edit masterdata or explicit view/edit permission for the accounting period; group-level access alone is insufficient. Default format=pdf returns HTTP 201 with data.url. CSV/XLSX return HTTP 200 with the file body. An Accept header whose first value is exactly text/html returns rendered HTML with HTTP 200 and overrides format.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::BalanceReportCreate {
/// accounting_period_id: 1,
/// end_date: "2026-12-31".parse()?,
/// start_date: "2026-01-01".parse()?,
/// ..Default::default()
/// };
/// let data = client.finance().reports().balance(&body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn balance(&self, body: &models::BalanceReportCreate) -> Result<Vec<u8>> {
let path = "/finance/reports/balance".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
/// Create profit and loss report
///
/// `POST /finance/reports/profit-loss`
///
/// Creates a profit-and-loss report from accounts whose account type has no balance-sheet classification. Requires finance edit masterdata or explicit view/edit permission for the accounting period; group-level access alone is insufficient. Default format=pdf returns HTTP 201 with data.url. CSV/XLSX return HTTP 200 with the file body. An Accept header whose first value is exactly text/html returns rendered HTML with HTTP 200 and overrides format.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::BalanceReportCreate {
/// accounting_period_id: 1,
/// end_date: "2026-12-31".parse()?,
/// start_date: "2026-01-01".parse()?,
/// ..Default::default()
/// };
/// let data = client.finance().reports().profit_loss(&body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn profit_loss(&self, body: &models::BalanceReportCreate) -> Result<Vec<u8>> {
let path = "/finance/reports/profit-loss".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
/// Create summed balance report
///
/// `POST /finance/reports/sum-balance`
///
/// Creates a trial balance (Summen- und Saldenliste) with opening balances, debit/credit totals for the chosen month and cumulative totals from January. accountTypes does not filter this report. Requires finance edit masterdata or explicit view/edit permission for the accounting period; group-level access alone is insufficient. Default format=pdf returns HTTP 201 with data.url. CSV/XLSX return HTTP 200 with the file body. An Accept header whose first value is exactly text/html returns rendered HTML with HTTP 200 and overrides format.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SumBalanceReportCreate {
/// accounting_period_id: 1,
/// month: 9,
/// ..Default::default()
/// };
/// let data = client.finance().reports().sum_balance(&body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn sum_balance(&self, body: &models::SumBalanceReportCreate) -> Result<Vec<u8>> {
let path = "/finance/reports/sum-balance".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
/// Issue new turnover report
///
/// `POST /finance/reports/turnover`
///
/// Creates monthly or quarterly account turnover columns. Columns use the calendar year of the accounting period’s start date; the total reflects the selected accounting period. Requires finance edit masterdata or explicit view/edit permission for the accounting period; group-level access alone is insufficient. Default format=pdf returns HTTP 201 with data.url. CSV/XLSX return HTTP 200 with the file body. An Accept header whose first value is exactly text/html returns rendered HTML with HTTP 200 and overrides format.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TurnoverReportCreate {
/// accounting_period_id: 1,
/// period: "monthly".into(),
/// ..Default::default()
/// };
/// let data = client.finance().reports().turnover(&body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn turnover(&self, body: &models::TurnoverReportCreate) -> Result<Vec<u8>> {
let path = "/finance/reports/turnover".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
}
/// `client.finance().reports().statement()`
#[derive(Clone, Copy)]
pub struct FinanceReportsStatementResource<'a> {
client: &'a Client,
}
impl<'a> FinanceReportsStatementResource<'a> {
pub fn accounts(&self) -> FinanceReportsStatementAccountsResource<'a> {
FinanceReportsStatementAccountsResource { client: self.client }
}
pub fn cost_centers(&self) -> FinanceReportsStatementCostCentersResource<'a> {
FinanceReportsStatementCostCentersResource { client: self.client }
}
}
/// `client.finance().reports().statement().accounts()`
#[derive(Clone, Copy)]
pub struct FinanceReportsStatementAccountsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceReportsStatementAccountsResource<'a> {
/// Create account statement report
///
/// `POST /finance/reports/statement/accounts/{accountId}`
///
/// Creates a ledger report of posted finance transactions for one account, sorted by document date. This is separate from imported bank-statement files. Missing date boundaries default independently to the account’s accounting period. Requires finance edit masterdata or explicit view/edit permission for the accounting period; group-level access alone is insufficient. Default format=pdf returns HTTP 201 with data.url. CSV/XLSX return HTTP 200 with the file body. An Accept header whose first value is exactly text/html returns rendered HTML with HTTP 200 and overrides format.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AccountStatementReportCreate {
/// end_date: Some(Some("2026-12-31".parse()?)),
/// ..Default::default()
/// };
/// let data = client.finance().reports().statement().accounts().create(21, &body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn create(&self, account_id: impl Display, body: &models::AccountStatementReportCreate) -> Result<Vec<u8>> {
let path = format!("/finance/reports/statement/accounts/{}", seg(account_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
}
/// `client.finance().reports().statement().cost_centers()`
#[derive(Clone, Copy)]
pub struct FinanceReportsStatementCostCentersResource<'a> {
client: &'a Client,
}
impl<'a> FinanceReportsStatementCostCentersResource<'a> {
/// Create cost center statement report
///
/// `POST /finance/reports/statement/costcenters/{costCenterId}`
///
/// Creates a ledger report of transactions assigned to one cost center, with income, expenditure and totals. Canceled transactions and their cancellation entries are excluded. Internal rebookings are omitted unless includeRebookings=true. Missing date boundaries default independently to the cost center’s accounting period. Requires finance edit masterdata or explicit view/edit permission for the accounting period; group-level access alone is insufficient. Default format=pdf returns HTTP 201 with data.url. CSV/XLSX return HTTP 200 with the file body. An Accept header whose first value is exactly text/html returns rendered HTML with HTTP 200 and overrides format.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::CostCenterStatementReportCreate {
/// end_date: Some(Some("2026-12-31".parse()?)),
/// ..Default::default()
/// };
/// let data = client.finance().reports().statement().cost_centers().create(21, &body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn create(&self, cost_center_id: impl Display, body: &models::CostCenterStatementReportCreate) -> Result<Vec<u8>> {
let path = format!("/finance/reports/statement/costcenters/{}", seg(cost_center_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
}
/// `client.finance().split_transactions()`
#[derive(Clone, Copy)]
pub struct FinanceSplitTransactionsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceSplitTransactionsResource<'a> {
/// Create new split transaction
///
/// `POST /finance/splittransactions`
///
/// Creates a grouped booking from new children or existing standalone booking IDs. Child notes, amounts, accounts and assignments are supplied separately; document date and number come from the parent. New child accounts must allow posting; supplied existing child accounts require period edit permission. Children must meet the shared-account and amount-sum rules. A new child must belong to an open period containing the document date. Generated tax amounts are derived from the gross child inputs. With one child the group is converted to an ordinary booking and HTTP 204 is returned without its ID. For multiple children, returns the split parent with child booking data.
///
/// Use [`Self::create_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SplitTransactionCreate {
/// amount: 30000,
/// document_date: "2026-09-14".parse()?,
/// note: Some("Offering and building fund".into()),
/// split_children: vec![models::SplitTransactionChildCreate {
/// account_id: 10,
/// amount: 7812,
/// contra_account_id: 11,
/// note: Some("Building fund".into()),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.finance().split_transactions().create(&body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::SplitTransactionCreate) -> Result<Option<models::SplitTransaction>> {
self.create_with(&Default::default(), body)
}
/// Create new split transaction
///
/// Like [`Self::create`], with query parameters.
///
/// `POST /finance/splittransactions`
///
/// Creates a grouped booking from new children or existing standalone booking IDs. Child notes, amounts, accounts and assignments are supplied separately; document date and number come from the parent. New child accounts must allow posting; supplied existing child accounts require period edit permission. Children must meet the shared-account and amount-sum rules. A new child must belong to an open period containing the document date. Generated tax amounts are derived from the gross child inputs. With one child the group is converted to an ordinary booking and HTTP 204 is returned without its ID. For multiple children, returns the split parent with child booking data.
pub fn create_with(&self, query: &PostFinanceSplittransactionsQuery, body: &models::SplitTransactionCreate) -> Result<Option<models::SplitTransaction>> {
let path = "/finance/splittransactions".to_owned();
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete split transaction
///
/// `DELETE /finance/splittransactions/{id}`
///
/// Deletes the entire split parent, its ordinary and generated tax children, related cancellation group, and attached receipts/files. Related statement movements are reset to open and unlinked. Requires edit permission for every child’s period. Each child must be mutable and its period open. dry_run=true returns HTTP 409 with a deletion assessment without deleting, including when deletion is possible.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().split_transactions().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete split transaction
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/splittransactions/{id}`
///
/// Deletes the entire split parent, its ordinary and generated tax children, related cancellation group, and attached receipts/files. Related statement movements are reset to open and unlinked. Requires edit permission for every child’s period. Each child must be mutable and its period open. dry_run=true returns HTTP 409 with a deletion assessment without deleting, including when deletion is possible.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceSplittransactionsIdQuery) -> Result<()> {
let path = format!("/finance/splittransactions/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Duplicate split transaction
///
/// `POST /finance/splittransactions/{id}/duplicate`
///
/// Creates a new split group from the source children, regenerating tax bookings and copying parent receipts/files. Requires permission to create each child using its source accounts and cost center; periods must be open and dates valid. Copies the original date, notes, donor assignments, waiver and cash discount. Uses the parent number plus -Kopie and numbered child suffixes, without guaranteeing uniqueness. New children are mutable and non-synced. Unlike ordinary duplicate, child donor/spouse consistency is checked during creation.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// let split_transaction = client.finance().split_transactions().duplicate(1, &body)?;
/// println!("{}", split_transaction.id);
/// # Ok(())
/// # }
/// ```
pub fn duplicate(&self, id: impl Display, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<models::SplitTransaction> {
let path = format!("/finance/splittransactions/{}/duplicate", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get a split transaction
///
/// `GET /finance/splittransactions/{id}`
///
/// Returns a split parent with its ordinary child bookings, including generated tax rows. The caller must be allowed to view every child; one inaccessible child rejects the entire request. Donor details and notes are censored per child according to donor visibility. include\[\]=bills adds receipts attached to the parent. The parent note is returned independently of the child notes.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-splittransactions-id");
/// let split_transaction = client.finance().split_transactions().get(1)?;
/// println!("{}", split_transaction.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::SplitTransaction> {
self.get_with(id, &Default::default())
}
/// Get a split transaction
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /finance/splittransactions/{id}`
///
/// Returns a split parent with its ordinary child bookings, including generated tax rows. The caller must be allowed to view every child; one inaccessible child rejects the entire request. Donor details and notes are censored per child according to donor visibility. include\[\]=bills adds receipts attached to the parent. The parent note is returned independently of the child notes.
pub fn get_with(&self, id: impl Display, query: &GetFinanceSplittransactionsIdQuery) -> Result<models::SplitTransaction> {
let path = format!("/finance/splittransactions/{}", seg(id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update split transaction, or convert to normal transaction, if only one split child is given,
///
/// `PUT /finance/splittransactions/{id}`
///
/// Replaces a split parent and its complete child list. Existing children not included in the request are deleted. Child notes, amounts, accounts and assignments are supplied separately; document date and number come from the parent. New child accounts must allow posting; supplied existing child accounts require period edit permission. Children must meet the shared-account and amount-sum rules. A new child must belong to an open period containing the document date. Generated tax amounts are derived from the gross child inputs. With one child the group is converted to an ordinary booking and HTTP 204 is returned without its ID. For multiple children, returns the split parent with child booking data.
///
/// Use [`Self::update_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SplitTransactionUpdate {
/// amount: 30000,
/// document_date: "2026-09-14".parse()?,
/// note: Some("Offering and building fund".into()),
/// split_children: vec![models::SplitTransactionChildCreate {
/// account_id: 10,
/// amount: 7812,
/// contra_account_id: 11,
/// note: Some("Building fund".into()),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.finance().split_transactions().update(1, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::SplitTransactionUpdate) -> Result<Option<models::SplitTransaction>> {
self.update_with(id, &Default::default(), body)
}
/// Update split transaction, or convert to normal transaction, if only one split child is given,
///
/// Like [`Self::update`], with query parameters.
///
/// `PUT /finance/splittransactions/{id}`
///
/// Replaces a split parent and its complete child list. Existing children not included in the request are deleted. Child notes, amounts, accounts and assignments are supplied separately; document date and number come from the parent. New child accounts must allow posting; supplied existing child accounts require period edit permission. Children must meet the shared-account and amount-sum rules. A new child must belong to an open period containing the document date. Generated tax amounts are derived from the gross child inputs. With one child the group is converted to an ordinary booking and HTTP 204 is returned without its ID. For multiple children, returns the split parent with child booking data.
pub fn update_with(&self, id: impl Display, query: &PutFinanceSplittransactionsIdQuery, body: &models::SplitTransactionUpdate) -> Result<Option<models::SplitTransaction>> {
let path = format!("/finance/splittransactions/{}", seg(id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
/// Cancel split transaction
///
/// `PUT /finance/splittransactions/{id}/storno`
///
/// Creates and returns one cancellation split parent containing opposite bookings for the original children, including tax bookings. Original records remain and reference their cancellations. Requires edit permission for each child period. Unlike ordinary cancellation, a second cancellation attempt is rejected with 403 if a child already has a cancellation. This operation does not explicitly require an open period. The original document date and amount are retained; the parent document number receives -Storno. The result is one object, not an array.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SplitTransactionStornoCreate {
/// note: "Incorrect allocation".into(),
/// ..Default::default()
/// };
/// let result = client.finance().split_transactions().update_storno(1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update_storno(&self, id: impl Display, body: &models::SplitTransactionStornoCreate) -> Result<models::SplitTransaction> {
let path = format!("/finance/splittransactions/{}/storno", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().tax_rates()`
#[derive(Clone, Copy)]
pub struct FinanceTaxRatesResource<'a> {
client: &'a Client,
}
impl<'a> FinanceTaxRatesResource<'a> {
/// Create a tax rate
///
/// `POST /finance/taxrates`
///
/// A tax rate combines a tax type, a percentage and the ledger account receiving the tax amount. Its accounting period is determined by that account. Requires finance “edit masterdata”. Returns HTTP 200 on success. The combination of taxTypeId, rate and accountId must be unique. The target account must belong to an open accounting period.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TaxRateCreate {
/// account_id: 5,
/// rate: 7.0,
/// tax_type_id: 4,
/// ..Default::default()
/// };
/// let result = client.finance().tax_rates().create(&body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::TaxRateCreate) -> Result<models::TaxRate> {
let path = "/finance/taxrates".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete tax rate
///
/// `DELETE /finance/taxrates/{id}`
///
/// Deletes this tax rate if no transactions or accounts reference it. Requires finance “edit masterdata”. dry_run=true returns the HTTP 409 conflict report without deleting, also when deletion is allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().tax_rates().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete tax rate
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/taxrates/{id}`
///
/// Deletes this tax rate if no transactions or accounts reference it. Requires finance “edit masterdata”. dry_run=true returns the HTTP 409 conflict report without deleting, also when deletion is allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceTaxratesIdQuery) -> Result<()> {
let path = format!("/finance/taxrates/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a tax rate
///
/// `GET /finance/taxrates/{id}`
///
/// A tax rate combines a tax type, a percentage and the ledger account receiving the tax amount. Its accounting period is determined by that account. Returns one definition by ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-taxrates-id");
/// let tax_rate = client.finance().tax_rates().get(1)?;
/// println!("{}", tax_rate.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::TaxRate> {
let path = format!("/finance/taxrates/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all tax rates
///
/// `GET /finance/taxrates`
///
/// A tax rate combines a tax type, a percentage and the ledger account receiving the tax amount. Its accounting period is determined by that account. Returns an unpaginated list. Optionally restrict results to the linked accounts’ accounting period. No result order is guaranteed; an unknown period returns an empty list. meta.count is the number returned.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-taxrates");
/// for tax_rate in client.finance().tax_rates().list()? {
/// println!("{}", tax_rate.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::TaxRate>> {
self.list_with(&Default::default())
}
/// Get all tax rates
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /finance/taxrates`
///
/// A tax rate combines a tax type, a percentage and the ledger account receiving the tax amount. Its accounting period is determined by that account. Returns an unpaginated list. Optionally restrict results to the linked accounts’ accounting period. No result order is guaranteed; an unknown period returns an empty list. meta.count is the number returned.
pub fn list_with(&self, query: &GetFinanceTaxratesQuery) -> Result<Vec<models::TaxRate>> {
let path = "/finance/taxrates".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update tax rate
///
/// `PUT /finance/taxrates/{id}`
///
/// Replaces this tax rate. Requires finance “edit masterdata”. When transactions reference the rate, only note may change; resend the existing rate, taxTypeId and accountId. Omitted note is cleared. The target account must belong to an open accounting period.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TaxRateUpdate {
/// account_id: 5,
/// rate: 7.0,
/// tax_type_id: 4,
/// ..Default::default()
/// };
/// let result = client.finance().tax_rates().update(1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::TaxRateUpdate) -> Result<models::TaxRate> {
let path = format!("/finance/taxrates/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().tax_types()`
#[derive(Clone, Copy)]
pub struct FinanceTaxTypesResource<'a> {
client: &'a Client,
}
impl<'a> FinanceTaxTypesResource<'a> {
/// Create a tax type
///
/// `POST /finance/taxtypes`
///
/// Tax types group tax rates by their accounting purpose, for example input tax or output tax. The percentage and receiving ledger account are configured on each tax rate. Requires finance “edit masterdata”. Returns HTTP 200 on success. The name must be unique.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TaxTypeCreate {
/// sort_key: 0,
/// ..Default::default()
/// };
/// let result = client.finance().tax_types().create(&body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::TaxTypeCreate) -> Result<models::TaxType> {
let path = "/finance/taxtypes".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete tax type
///
/// `DELETE /finance/taxtypes/{id}`
///
/// Deletes this tax type if no tax rates reference it. Requires finance “edit masterdata”. dry_run=true returns the HTTP 409 conflict report without deleting, also when deletion is allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().tax_types().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete tax type
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/taxtypes/{id}`
///
/// Deletes this tax type if no tax rates reference it. Requires finance “edit masterdata”. dry_run=true returns the HTTP 409 conflict report without deleting, also when deletion is allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceTaxtypesIdQuery) -> Result<()> {
let path = format!("/finance/taxtypes/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a tax type
///
/// `GET /finance/taxtypes/{id}`
///
/// Tax types group tax rates by their accounting purpose, for example input tax or output tax. The percentage and receiving ledger account are configured on each tax rate. Returns one definition by ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-taxtypes-id");
/// let tax_type = client.finance().tax_types().get(1)?;
/// println!("{:?}", tax_type.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::TaxType> {
let path = format!("/finance/taxtypes/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all tax types
///
/// `GET /finance/taxtypes`
///
/// Tax types group tax rates by their accounting purpose, for example input tax or output tax. The percentage and receiving ledger account are configured on each tax rate. Returns an unpaginated list. Results are ordered by sortKey, then name, ascending. meta.count is the number returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-taxtypes");
/// for tax_type in client.finance().tax_types().list()? {
/// println!("{:?}", tax_type.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::TaxType>> {
let path = "/finance/taxtypes".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update tax type
///
/// `PUT /finance/taxtypes/{id}`
///
/// Replaces this tax type. Requires finance “edit masterdata”. All required creation fields must be supplied again. Omitted name is cleared; names must remain unique.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TaxTypeUpdate {
/// sort_key: 0,
/// ..Default::default()
/// };
/// let result = client.finance().tax_types().update(1, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::TaxTypeUpdate) -> Result<models::TaxType> {
let path = format!("/finance/taxtypes/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().templates()`
#[derive(Clone, Copy)]
pub struct FinanceTemplatesResource<'a> {
client: &'a Client,
}
impl<'a> FinanceTemplatesResource<'a> {
/// Apply finance template
///
/// `POST /finance/templates/{id}`
///
/// Applies a stored finance-template file to an existing accounting period with no transactions. Existing accounts and tax rates are removed before the template definitions are added. Existing account types/classes/groups and tax types are reused by normalized name; missing ones are added. Existing cost centers are retained, with additional matching/update rules. Cash-discount definitions are not imported by the current executors. This operation has no dry-run mode and no encompassing transaction; a later failure can leave earlier changes applied. Returns HTTP 204 without a body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = PostFinanceTemplatesIdQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// client.finance().templates().create(1, &query)?;
/// # Ok(())
/// # }
/// ```
pub fn create(&self, id: impl Display, query: &PostFinanceTemplatesIdQuery) -> Result<()> {
let path = format!("/finance/templates/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Export a finance template
///
/// `GET /finance/templates/export`
///
/// Downloads finance master data for an existing, visible accounting period as a portable JSON attachment. The root object contains definition collections directly, without a data wrapper or metadata. Accounts, tax rates, cash discounts and cost centers come from the selected period; account types/classes/groups and tax types are installation-wide. The export follows the caller’s master-data visibility and may therefore contain only a subset.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-templates-export");
/// let query = GetFinanceTemplatesExportQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let export = client.finance().templates().get_export(&query)?;
/// println!("{:?}", export);
/// # Ok(())
/// # }
/// ```
pub fn get_export(&self, query: &GetFinanceTemplatesExportQuery) -> Result<models::FinanceTemplateExport> {
let path = "/finance/templates/export".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all finance templates
///
/// `GET /finance/templates`
///
/// Returns stored finance-template files with per-collection definition counts. The list is unpaginated and has no guaranteed order. meta.count is the number returned. Files are selected by the finance_template domain.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-templates");
/// for template in client.finance().templates().list()? {
/// println!("{}", template.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::FinanceTemplate>> {
let path = "/finance/templates".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.finance().transaction_purposes()`
#[derive(Clone, Copy)]
pub struct FinanceTransactionPurposesResource<'a> {
client: &'a Client,
}
impl<'a> FinanceTransactionPurposesResource<'a> {
/// Create new transaction purpose
///
/// `POST /finance/transactionpurposes`
///
/// Creates a transaction purpose and returns HTTP 201. Requires finance “edit masterdata” and an open period for purposeAccountId. When costCenterId is supplied, its period must match the fixed account and all resolved selectable accounts.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TransactionPurposeCreate {
/// account_ids: vec![1, 2],
/// is_income: true,
/// name: "Donations for youth work".into(),
/// purpose_account_id: 3,
/// sort_key: 0,
/// ..Default::default()
/// };
/// let result = client.finance().transaction_purposes().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::TransactionPurposeCreate) -> Result<models::TransactionPurpose> {
let path = "/finance/transactionpurposes".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete transaction purpose
///
/// `DELETE /finance/transactionpurposes/{id}`
///
/// Deletes the transaction-purpose preset and its selectable-account links. Requires finance “edit masterdata”. Existing transaction records are not deleted. dry_run=true returns the HTTP 409 report without deleting, also when deletion is allowed.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().transaction_purposes().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete transaction purpose
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/transactionpurposes/{id}`
///
/// Deletes the transaction-purpose preset and its selectable-account links. Requires finance “edit masterdata”. Existing transaction records are not deleted. dry_run=true returns the HTTP 409 report without deleting, also when deletion is allowed.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceTransactionpurposesIdQuery) -> Result<()> {
let path = format!("/finance/transactionpurposes/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a transaction purpose
///
/// `GET /finance/transactionpurposes/{id}`
///
/// Returns one transaction purpose. A transaction purpose is a reusable preset for simplified bookkeeping. It fixes one ledger account, offers a list of accounts for the other side, and can assign a cost center. isIncome selects an income or expense preset; it is not the free-text note of a bank statement. Requires finance “view”; there is no additional period-specific visibility filter in this endpoint.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-transactionpurposes-id");
/// let transaction_purpose = client.finance().transaction_purposes().get(1)?;
/// println!("{}", transaction_purpose.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::TransactionPurpose> {
let path = format!("/finance/transactionpurposes/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all transaction purposes
///
/// `GET /finance/transactionpurposes`
///
/// A transaction purpose is a reusable preset for simplified bookkeeping. It fixes one ledger account, offers a list of accounts for the other side, and can assign a cost center. isIncome selects an income or expense preset; it is not the free-text note of a bank statement. Requires finance “view”. Returns the complete, unpaginated list across periods, ordered by sortKey and then name ascending. This endpoint does not apply the period/group filtering used by /finance/masterdata. meta.count is the number returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-transactionpurposes");
/// for transaction_purpose in client.finance().transaction_purposes().list()? {
/// println!("{}", transaction_purpose.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::TransactionPurpose>> {
let path = "/finance/transactionpurposes".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update transaction purpose
///
/// `PUT /finance/transactionpurposes/{id}`
///
/// Replaces a transaction purpose, including the complete list of selectable accounts. Requires finance “edit masterdata” and an open period for the new purposeAccountId. Omitted costCenterId clears it. If a cost center is supplied, all resolved accounts must belong to its period.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TransactionPurposeUpdate {
/// account_ids: vec![1, 2],
/// is_income: true,
/// name: "Donations for youth work".into(),
/// purpose_account_id: 3,
/// sort_key: 0,
/// ..Default::default()
/// };
/// let result = client.finance().transaction_purposes().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::TransactionPurposeUpdate) -> Result<models::TransactionPurpose> {
let path = format!("/finance/transactionpurposes/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.finance().transactions()`
#[derive(Clone, Copy)]
pub struct FinanceTransactionsResource<'a> {
client: &'a Client,
}
impl<'a> FinanceTransactionsResource<'a> {
/// Create multiple transactions
///
/// `POST /finance/transactions/bulkcreate`
///
/// Creates a non-empty JSON array of bookings in input order and returns the main bookings with meta.count. Each item supplies its own document number and accounts; items may belong to different accounting periods. Both accounts must allow posting and all related finance references within an item must belong to the same period. Periods must be open and contain each documentDate. Input validation runs before creation, followed by a shared database transaction. The optional query flag skips the normal donation-account/donor constraint for all items, but joint-donor consistency still applies. Use actual JSON boolean and integer values.
///
/// Use [`Self::bulk_create_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: Vec<models::TransactionBulkCreateItem> = vec![models::TransactionBulkCreateItem {
/// account_id: 10,
/// amount: 7812,
/// contra_account_id: 11,
/// document_date: "2019-01-14".parse()?,
/// note: "Donation service offering".into(),
/// document_number: "2026-42".into(),
/// ..Default::default()
/// }];
/// for transaction in client.finance().transactions().bulk_create(&body)? {
/// println!("{}", transaction.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn bulk_create(&self, body: &Vec<models::TransactionBulkCreateItem>) -> Result<Vec<models::Transaction>> {
self.bulk_create_with(&Default::default(), body)
}
/// Create multiple transactions
///
/// Like [`Self::bulk_create`], with query parameters.
///
/// `POST /finance/transactions/bulkcreate`
///
/// Creates a non-empty JSON array of bookings in input order and returns the main bookings with meta.count. Each item supplies its own document number and accounts; items may belong to different accounting periods. Both accounts must allow posting and all related finance references within an item must belong to the same period. Periods must be open and contain each documentDate. Input validation runs before creation, followed by a shared database transaction. The optional query flag skips the normal donation-account/donor constraint for all items, but joint-donor consistency still applies. Use actual JSON boolean and integer values.
pub fn bulk_create_with(&self, query: &PostFinanceTransactionsBulkcreateQuery, body: &Vec<models::TransactionBulkCreateItem>) -> Result<Vec<models::Transaction>> {
let path = "/finance/transactions/bulkcreate".to_owned();
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Create new transaction
///
/// `POST /finance/transactions`
///
/// Creates one booking and, if requested, its tax booking. Requires permission to post on both accounts and either edit permission for the period or a permitted booking purpose matching the accounts and cost center. The accounting period must be open and contain documentDate. Related finance objects must belong to that same period. Unless ignoreDonationConstraint=true is supplied in the query, crediting a donation account from a non-donation account requires a donor. Joint donors must have an existing spouse relationship. Returns the main booking; generated tax booking IDs are included in it.
///
/// Use [`Self::create_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TransactionCreate {
/// account_id: 10,
/// amount: 7812,
/// contra_account_id: 11,
/// document_date: "2019-01-14".parse()?,
/// note: "Donation service offering".into(),
/// ..Default::default()
/// };
/// let result = client.finance().transactions().create(&body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::TransactionCreate) -> Result<models::Transaction> {
self.create_with(&Default::default(), body)
}
/// Create new transaction
///
/// Like [`Self::create`], with query parameters.
///
/// `POST /finance/transactions`
///
/// Creates one booking and, if requested, its tax booking. Requires permission to post on both accounts and either edit permission for the period or a permitted booking purpose matching the accounts and cost center. The accounting period must be open and contain documentDate. Related finance objects must belong to that same period. Unless ignoreDonationConstraint=true is supplied in the query, crediting a donation account from a non-donation account requires a donor. Joint donors must have an existing spouse relationship. Returns the main booking; generated tax booking IDs are included in it.
pub fn create_with(&self, query: &PostFinanceTransactionsQuery, body: &models::TransactionCreate) -> Result<models::Transaction> {
let path = "/finance/transactions".to_owned();
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete transaction
///
/// `DELETE /finance/transactions/{id}`
///
/// Deletes a standalone booking and its generated tax and cancellation bookings, together with attached receipts/files. Related statement movements are reset to open and unlinked. Requires edit permission for the accounting period, which must be open. Immutable bookings, generated tax bookings and split children cannot be deleted directly. A cancellation booking can be deleted to remove the cancellation link from its original booking. dry_run=true performs the same eligibility checks without deleting and returns HTTP 409 with the deletion assessment, including when deletion is possible.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.finance().transactions().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete transaction
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /finance/transactions/{id}`
///
/// Deletes a standalone booking and its generated tax and cancellation bookings, together with attached receipts/files. Related statement movements are reset to open and unlinked. Requires edit permission for the accounting period, which must be open. Immutable bookings, generated tax bookings and split children cannot be deleted directly. A cancellation booking can be deleted to remove the cancellation link from its original booking. dry_run=true performs the same eligibility checks without deleting and returns HTTP 409 with the deletion assessment, including when deletion is possible.
pub fn delete_with(&self, id: impl Display, query: &DeleteFinanceTransactionsIdQuery) -> Result<()> {
let path = format!("/finance/transactions/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Duplicate transaction
///
/// `POST /finance/transactions/{id}/duplicate`
///
/// Copies a standalone booking into its original open accounting period. Requires permission to create a booking with the source accounts and cost center. Copies document date, accounts, note, donor assignments, waiver and cash discount; recreates tax bookings and copies attached receipts/files. The document number receives the suffix -Kopie; this does not reserve or generate a unique number. The new booking starts mutable and non-synced and is not linked as a cancellation. Split children cannot be duplicated here. The response contains the new main booking; copied bills can be retrieved with include\[\]=bills.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// let transaction = client.finance().transactions().duplicate(1, &body)?;
/// println!("{}", transaction.id);
/// # Ok(())
/// # }
/// ```
pub fn duplicate(&self, id: impl Display, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<models::Transaction> {
let path = format!("/finance/transactions/{}/duplicate", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get a transaction
///
/// `GET /finance/transactions/{id}`
///
/// Returns a single booking, including a child of a split transaction. Requires view or edit permission for its accounting period, or the corresponding group permission for its assigned cost center. Donor visibility is checked separately: a user who may see the booking but not its donors receives censored person placeholders and a null note. Request include\[\]=bills to include attached receipts. Related tax, cancellation and split bookings are referenced by ID.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-transactions-id");
/// let transaction = client.finance().transactions().get(1)?;
/// println!("{}", transaction.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::Transaction> {
self.get_with(id, &Default::default())
}
/// Get a transaction
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /finance/transactions/{id}`
///
/// Returns a single booking, including a child of a split transaction. Requires view or edit permission for its accounting period, or the corresponding group permission for its assigned cost center. Donor visibility is checked separately: a user who may see the booking but not its donors receives censored person placeholders and a null note. Request include\[\]=bills to include attached receipts. Related tax, cancellation and split bookings are referenced by ID.
pub fn get_with(&self, id: impl Display, query: &GetFinanceTransactionsIdQuery) -> Result<models::Transaction> {
let path = format!("/finance/transactions/{}", seg(id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Export transactions as CSV
///
/// `GET /finance/transactions/csv`
///
/// Downloads all matching bookings without pagination or a JSON wrapper. Supports the listed booking filters; page, limit, include, exclude_stornos and exclude_paybacks are not evaluated. Both accounts must be visible. Without an explicit cost-center filter, users without permission for the whole period are restricted to their accessible cost centers. Donor details and notes are censored where required, but the donor-ID filter itself is accepted without the list endpoint’s additional filter-permission check. target selects the column layout. CSV uses semicolons, UTF-8 with BOM, localized column labels and locale-dependent amount formatting in major currency units. Use /finance/transactions/export for new integrations.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetFinanceTransactionsCsvQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let data = client.finance().transactions().get_csv(&query)?;
/// std::fs::write("ergebnis.csv", &data)?;
/// # Ok(())
/// # }
/// ```
#[deprecated = "GET /finance/transactions/csv is deprecated in the ChurchTools API. Use /finance/transactions/export for new integrations."]
pub fn get_csv(&self, query: &GetFinanceTransactionsCsvQuery) -> Result<Vec<u8>> {
let path = "/finance/transactions/csv".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Export transactions in DATEV format
///
/// `GET /finance/transactions/datevexport`
///
/// Downloads a semicolon-separated DATEV EXTF booking-batch CSV with UTF-8 BOM, a metadata row and a column-header row. Includes all matching bookings without pagination, including cancellation and tax rows. The listed booking filters apply; exclude_stornos and exclude_paybacks are not evaluated. Accounts and default cost-center scope are restricted by permissions. Uses the client’s DATEV consultant/client numbers and the period’s start date. Current output uses EUR and debit indicator S. Choose order_by=date&order_direction=ASC because the header takes the first and last row dates as its range. An empty result currently fails during header creation.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetFinanceTransactionsDatevexportQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let data = client.finance().transactions().get_datev_export(&query)?;
/// std::fs::write("ergebnis.csv", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_datev_export(&self, query: &GetFinanceTransactionsDatevexportQuery) -> Result<Vec<u8>> {
let path = "/finance/transactions/datevexport".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Check if a document number is available
///
/// `GET /finance/transactions/documentnumberavailable`
///
/// Checks whether an ordinary transaction row in the accounting period uses document_number. Returns HTTP 200 without a body when available and HTTP 409 without a body when occupied. Includes synced and cancellation rows and performs a database string comparison. It does not normalize split-parent or copy suffixes as the next-number suggestion does, and does not reserve the number. Requires visibility of the accounting period.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetFinanceTransactionsDocumentnumberavailableQuery {
/// accounting_period_id: Some(1),
/// document_number: Some("2024-001".into()),
/// ..Default::default()
/// };
/// client.finance().transactions().get_document_number_available(&query)?;
/// # Ok(())
/// # }
/// ```
pub fn get_document_number_available(&self, query: &GetFinanceTransactionsDocumentnumberavailableQuery) -> Result<()> {
let path = "/finance/transactions/documentnumberavailable".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
/// Export transactions
///
/// `GET /finance/transactions/export`
///
/// Downloads all matching bookings without pagination or a JSON wrapper. Supports the listed booking filters; page, limit, include, exclude_stornos and exclude_paybacks are not evaluated. Both accounts must be visible. Without an explicit cost-center filter, users without permission for the whole period are restricted to their accessible cost centers. Donor details and notes are censored where required, but the donor-ID filter itself is accepted without the list endpoint’s additional filter-permission check. target selects the column layout. CSV uses semicolons, UTF-8 with BOM, localized column labels and locale-dependent amount formatting in major currency units. format=xlsx returns an Excel workbook instead of CSV; PDF is not supported.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = GetFinanceTransactionsExportQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let data = client.finance().transactions().get_export(&query)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_export(&self, query: &GetFinanceTransactionsExportQuery) -> Result<Vec<u8>> {
let path = "/finance/transactions/export".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Get IDs of all transactions
///
/// `GET /finance/transactions/ids`
///
/// Returns ordinary transaction IDs for visible accounting periods, including split children, tax bookings and cancellations. With accounting_period_id, data is a flat array of decimal ID strings. Without it, data is an object keyed by accounting-period ID; periods without transactions are omitted and an entirely empty result is serialized as an empty array. Ordering is unspecified. The endpoint checks period visibility and does not apply the transaction list's account or cost-center filters; an ID in this result does not guarantee access to the corresponding transaction. Use the paginated transaction list for that purpose.
///
/// Use [`Self::get_ids_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-transactions-ids");
/// let result = client.finance().transactions().get_ids()?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_ids(&self) -> Result<serde_json::Value> {
self.get_ids_with(&Default::default())
}
/// Get IDs of all transactions
///
/// Like [`Self::get_ids`], with query parameters.
///
/// `GET /finance/transactions/ids`
///
/// Returns ordinary transaction IDs for visible accounting periods, including split children, tax bookings and cancellations. With accounting_period_id, data is a flat array of decimal ID strings. Without it, data is an object keyed by accounting-period ID; periods without transactions are omitted and an entirely empty result is serialized as an empty array. Ordering is unspecified. The endpoint checks period visibility and does not apply the transaction list's account or cost-center filters; an ID in this result does not guarantee access to the corresponding transaction. Use the paginated transaction list for that purpose.
pub fn get_ids_with(&self, query: &GetFinanceTransactionsIdsQuery) -> Result<serde_json::Value> {
let path = "/finance/transactions/ids".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get suggestion for next document number
///
/// `GET /finance/transactions/nextdocumentnumber`
///
/// Suggests a document number for a new booking. Uses the most recently inserted non-synced, non-cancellation transaction as its base, not the greatest existing number. For split children the child suffix is removed; the copy suffix -Kopie is removed as well. A trailing number is incremented with its zero padding preserved; a base without digits receives -1. Existing normalized non-cancellation numbers are skipped. With no eligible base transaction, returns the string 1. Requires visibility of the accounting period. The suggestion is not reserved and concurrent clients can receive the same number.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-transactions-nextdocumentnumber");
/// let query = GetFinanceTransactionsNextdocumentnumberQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let result = client.finance().transactions().get_next_document_number(&query)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_next_document_number(&self, query: &GetFinanceTransactionsNextdocumentnumberQuery) -> Result<String> {
let path = "/finance/transactions/nextdocumentnumber".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Calculate a journal summary with previous-year comparison
///
/// `GET /finance/transactions/summary`
///
/// Calculates a journal summary for one accounting period. calculation_type selects account debit/credit balances, cost-center income/expense, or net donations. Supplying it also saves the current user’s preference for the combination of account, cost-center and donor filters. If omitted, the saved preference is used; without a preference the first non-empty filter selects accounts, then cost centers, then donors. Without a usable filter/type the request fails. Date limits default to the accounting period boundaries. Previous-year comparison shifts both dates back one year and uses the previous accounting period of the same client. Monetary values are minor currency units. The donor filter is removed unless the caller has view permission for the entire period, even if group donor visibility is available. include_ids, exclude_ids, pagination and exclusion flags are not evaluated by this endpoint.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-transactions-summary");
/// let query = GetFinanceTransactionsSummaryQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// let result = client.finance().transactions().get_summary(&query)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_summary(&self, query: &GetFinanceTransactionsSummaryQuery) -> Result<serde_json::Value> {
let path = "/finance/transactions/summary".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all transactions
///
/// `GET /finance/transactions`
///
/// Lists bookings in one accounting period, including split children and generated tax or cancellation bookings. Both accounts must be visible to the caller. With no cost_center_ids and no permission for the entire period, the list is limited to accessible cost centers. Donor filtering is silently ignored unless the caller has view permission for the period or a group permission to see donors in cost centers. Donor details are independently censored per booking. All filters are combined; an empty ID array does not restrict results. Send array filters using bracket query syntax, for example account_ids\[\]=10&account_ids\[\]=11. The pagination total describes the filtered result; meta.all ignores the optional filters except exclude_stornos and retains the visibility restrictions.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-finance-transactions");
/// let query = GetFinanceTransactionsQuery {
/// accounting_period_id: Some(1),
/// ..Default::default()
/// };
/// for transaction in client.finance().transactions().list(&query)? {
/// println!("{}", transaction.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetFinanceTransactionsQuery) -> Result<Vec<models::Transaction>> {
let path = "/finance/transactions".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all transactions
///
/// Like [`Self::list`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetFinanceTransactionsQuery) -> Items<models::Transaction> {
let path = "/finance/transactions".to_owned();
self.client.items(&path, query.to_query())
}
/// Finalize or delete a filtered set of bookings
///
/// `PATCH /finance/transactions`
///
/// Runs one batch action on bookings selected by a non-empty array of filters. Conditions within each filter are combined with AND and filters with OR. Requires edit permission for every specified accounting period. isImmutable=true finalizes selected bookings and expands the selection to related tax bookings, tax bases and originals of selected cancellations. All children of any affected split booking must be covered, otherwise HTTP 403 is returned. delete=true performs period cleanup: it can delete immutable bookings and does not apply the normal open-period or standalone-booking checks. Deletion removes related records through the deletion service and has no dry-run mode. If both actions are true, finalization wins. Always send a non-empty filters array; the current backend does not safely restrict an empty selection.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TransactionBatchUpdate {
/// changeset: models::TransactionBatchUpdateChangeset::default(),
/// filters: vec![models::TransactionBatchFilter {
/// accounting_period_id: 1,
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.finance().transactions().patch(&body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, body: &models::TransactionBatchUpdate) -> Result<serde_json::Value> {
let path = "/finance/transactions".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
/// Update transaction
///
/// `PUT /finance/transactions/{id}`
///
/// Updates a standalone booking. Requires edit permission for its original accounting period and posting permission on the supplied accounts. The original period must be open and the booking mutable; split children, generated tax bookings and cancellation bookings cannot be edited here. Required fields replace existing values. Missing cost center, donors and tax rate are cleared, while missing cash-discount fields retain their previous values. isImmutable=true finalizes the booking and any tax booking. Joint-donor consistency is checked when either donor ID changes.
///
/// Use [`Self::update_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TransactionUpdate {
/// account_id: 10,
/// amount: 7812,
/// contra_account_id: 11,
/// document_date: "2019-01-14".parse()?,
/// note: "Donation service offering".into(),
/// document_number: "2026-42".into(),
/// ..Default::default()
/// };
/// let result = client.finance().transactions().update(1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::TransactionUpdate) -> Result<models::Transaction> {
self.update_with(id, &Default::default(), body)
}
/// Update transaction
///
/// Like [`Self::update`], with query parameters.
///
/// `PUT /finance/transactions/{id}`
///
/// Updates a standalone booking. Requires edit permission for its original accounting period and posting permission on the supplied accounts. The original period must be open and the booking mutable; split children, generated tax bookings and cancellation bookings cannot be edited here. Required fields replace existing values. Missing cost center, donors and tax rate are cleared, while missing cash-discount fields retain their previous values. isImmutable=true finalizes the booking and any tax booking. Joint-donor consistency is checked when either donor ID changes.
pub fn update_with(&self, id: impl Display, query: &PutFinanceTransactionsIdQuery, body: &models::TransactionUpdate) -> Result<models::Transaction> {
let path = format!("/finance/transactions/{}", seg(id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
/// Cancel transaction
///
/// `PUT /finance/transactions/{id}/storno`
///
/// Cancels a standalone booking by creating an opposite booking with swapped debit and credit accounts, the same amount and document date, and a -Storno document-number suffix. The original remains in place and references its cancellation. A tax booking is cancelled recursively. Requires edit permission for the period; split children must be cancelled through their parent endpoint. This operation does not require a mutable booking or check that the period is open. Repeating it updates the existing cancellation without creating another one; targeting a cancellation itself is a no-op. Returns HTTP 200 without a response body. Retrieve the original afterwards to obtain stornoTransactionId.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TransactionStornoCreate {
/// note: "Incorrect amount".into(),
/// ..Default::default()
/// };
/// client.finance().transactions().update_storno(1, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update_storno(&self, id: impl Display, body: &models::TransactionStornoCreate) -> Result<()> {
let path = format!("/finance/transactions/{}/storno", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.followups()`
#[derive(Clone, Copy)]
pub struct FollowupsResource<'a> {
client: &'a Client,
}
impl<'a> FollowupsResource<'a> {
/// Complete follow-up
///
/// `POST /followups/{followUpId}/complete`
///
/// Sets `doneDate` to the current timestamp and records completion history. The subject person must be visible. Group-associated follow-ups require "churchdb +do followup" permission in that group. A supplied nonzero `successGroupId` adds or updates the subject’s membership in that selected group, including overwriting an existing membership’s role/status. Configured fixed-group/group-type restrictions are checked; a configured group is not selected automatically. Emits a completion event, which can trigger configured continuations or routines. Repeating this operation replaces `doneDate`, writes another history entry and emits another event. Due dates are retained.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-followups-followUpId-complete");
/// let body = models::FollowUpCompletionCreate {
/// success_group_id: Some(Some(42)),
/// ..Default::default()
/// };
/// let followup = client.followups().complete(2, &body)?;
/// println!("{}", followup.title);
/// # Ok(())
/// # }
/// ```
pub fn complete(&self, follow_up_id: impl Display, body: &models::FollowUpCompletionCreate) -> Result<models::FollowUp2> {
let path = format!("/followups/{}/complete", seg(follow_up_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete follow-up
///
/// `DELETE /followups/{followUpId}`
///
/// Deletes the follow-up and records deletion history in a transaction. Its specification is also deleted when it is not shared; a shared specification remains. Deletion requires access to the subject person and, for a group-associated follow-up, follow-up administration rights in that group. No dryRun/dependency-preview behavior is implemented. This removes the follow-up rather than marking it finished; it does not reverse group memberships or routine effects caused by earlier completion.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.followups().delete(2)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, follow_up_id: impl Display) -> Result<()> {
let path = format!("/followups/{}", seg(follow_up_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Dismiss follow-up
///
/// `POST /followups/{followUpId}/dismiss`
///
/// Marks the follow-up as finished by setting `doneDate` to the current timestamp and recording a dismissal history entry. The subject person must be visible. Group-associated follow-ups require "churchdb +do followup" permission in that group. No success-group membership is changed and no completion event is emitted. Completion and dismissal both appear through `doneDate` and differ only in history. Repeating dismissal updates `doneDate` and creates another history entry.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-followups-followUpId-dismiss");
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// let followup = client.followups().dismiss(2, &body)?;
/// println!("{}", followup.title);
/// # Ok(())
/// # }
/// ```
pub fn dismiss(&self, follow_up_id: impl Display, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<models::FollowUp2> {
let path = format!("/followups/{}/dismiss", seg(follow_up_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get follow-up
///
/// `GET /followups/{followUpId}`
///
/// Returns one follow-up, including its subject person/group context, responsible person, current/original due dates and configured completion group. The current owner may view it; a group-associated follow-up is also visible to users with that group’s follow-up execution or administration rights. This direct check is broader than the list selection: group follow-ups assigned to another person can be read by eligible group staff even when omitted from their list. The response does not include notes or history, nor indicate whether its underlying specification is shared.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-followups-followUpId");
/// let followup = client.followups().get(2)?;
/// println!("{}", followup.title);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, follow_up_id: impl Display) -> Result<models::FollowUp2> {
let path = format!("/followups/{}", seg(follow_up_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List follow-ups assigned to the current user or eligible groups
///
/// `GET /followups`
///
/// Returns follow-ups owned by the current user plus unassigned group follow-ups for groups where the user has follow-up execution or administration rights. This includes personal and membership follow-ups; it is not an unrestricted list of every follow-up for a visible person. Archived subject persons are excluded. Date filters use `effectiveDueDate` and are combined with OR. Results are sorted by doneDate descending, then effectiveDueDate ascending, then ID ascending; finished items can precede open ones. Page/limit slice the result, but meta only contains count for this page, without a total or last page.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-followups");
/// for followup in client.followups().list()? {
/// println!("{}", followup.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::FollowUp2>> {
self.list_with(&Default::default())
}
/// List follow-ups assigned to the current user or eligible groups
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /followups`
///
/// Returns follow-ups owned by the current user plus unassigned group follow-ups for groups where the user has follow-up execution or administration rights. This includes personal and membership follow-ups; it is not an unrestricted list of every follow-up for a visible person. Archived subject persons are excluded. Date filters use `effectiveDueDate` and are combined with OR. Results are sorted by doneDate descending, then effectiveDueDate ascending, then ID ascending; finished items can precede open ones. Page/limit slice the result, but meta only contains count for this page, without a total or last page.
pub fn list_with(&self, query: &GetFollowupsQuery) -> Result<Vec<models::FollowUp2>> {
let path = "/followups".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List follow-ups assigned to the current user or eligible groups
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetFollowupsQuery) -> Items<models::FollowUp2> {
let path = "/followups".to_owned();
self.client.items(&path, query.to_query())
}
/// Add a note to a follow-up
///
/// `POST /followups/{followUpId}/notes`
///
/// Creates a note linked to this follow-up. With `also_apply_to_person=true`, the same note is also linked to the subject person. `commentViewerId` applies only to the person link. The subject person must be visible; group-associated follow-ups require "churchdb +do followup" permission in that group.
///
/// Use [`Self::notes_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::FollowUpNoteCreate {
/// comment: "Called Alex; another conversation is planned for next week.".into(),
/// ..Default::default()
/// };
/// client.followups().notes(2, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn notes(&self, follow_up_id: impl Display, body: &models::FollowUpNoteCreate) -> Result<()> {
self.notes_with(follow_up_id, &Default::default(), body)
}
/// Add a note to a follow-up
///
/// Like [`Self::notes`], with query parameters.
///
/// `POST /followups/{followUpId}/notes`
///
/// Creates a note linked to this follow-up. With `also_apply_to_person=true`, the same note is also linked to the subject person. `commentViewerId` applies only to the person link. The subject person must be visible; group-associated follow-ups require "churchdb +do followup" permission in that group.
pub fn notes_with(&self, follow_up_id: impl Display, query: &PostFollowupsFollowUpIdNotesQuery, body: &models::FollowUpNoteCreate) -> Result<()> {
let path = format!("/followups/{}/notes", seg(follow_up_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Postpone follow-up
///
/// `POST /followups/{followUpId}/postpone`
///
/// Changes `effectiveDueDate` to a future calendar date and records postponement history. `dueDate` remains the original plan. The subject person must be visible. Group-associated follow-ups require "churchdb +do followup" permission in that group. Today is rejected. The method does not clear `doneDate` or reject already-finished follow-ups, so use reset to reopen one. No completion event or success-group action is performed.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-followups-followUpId-postpone");
/// let body = models::FollowUpPostponeCreate {
/// due_date: "2026-12-01".parse()?,
/// ..Default::default()
/// };
/// let followup = client.followups().postpone(2, &body)?;
/// println!("{}", followup.title);
/// # Ok(())
/// # }
/// ```
pub fn postpone(&self, follow_up_id: impl Display, body: &models::FollowUpPostponeCreate) -> Result<models::FollowUp2> {
let path = format!("/followups/{}/postpone", seg(follow_up_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Reset follow-up
///
/// `POST /followups/{followUpId}/reset`
///
/// Reopens the follow-up by clearing `doneDate` and records reset history. A supplied future `dueDate` becomes `effectiveDueDate`; otherwise the original `dueDate` is restored as the effective date. The original `dueDate` is unchanged. The subject person must be visible. Group-associated follow-ups require "churchdb +do followup" permission in that group. Reset is also accepted for an already-open follow-up. It does not undo previous completion effects.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-followups-followUpId-reset");
/// let body = models::FollowUpResetCreate {
/// due_date: Some(Some("2026-12-01".parse()?)),
/// ..Default::default()
/// };
/// let followup = client.followups().reset(2, &body)?;
/// println!("{}", followup.title);
/// # Ok(())
/// # }
/// ```
pub fn reset(&self, follow_up_id: impl Display, body: &models::FollowUpResetCreate) -> Result<models::FollowUp2> {
let path = format!("/followups/{}/reset", seg(follow_up_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Update follow-up
///
/// `PUT /followups/{followUpId}`
///
/// Updates mutable fields of the specified follow-up.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-followups-followUpId");
/// let body = serde_json::json!({
/// "title": "Call Peter"
/// });
/// let result = client.followups().update(2, &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, follow_up_id: impl Display, body: &serde_json::Value) -> Result<models::FollowUp2> {
let path = format!("/followups/{}", seg(follow_up_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.further_links()`
#[derive(Clone, Copy)]
pub struct FurtherLinksResource<'a> {
client: &'a Client,
}
impl<'a> FurtherLinksResource<'a> {
/// Create further link
///
/// `POST /furtherlinks`
///
/// Create a new further link.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-furtherlinks");
/// let body = models::FurtherLinkCreate {
/// description: Some("Our church's NextCloud".into()),
/// image_url: Some("https://example.org".into()),
/// name: "NextCloud".into(),
/// sort_key: 1.5,
/// url: "https://example.org".into(),
/// ..Default::default()
/// };
/// let result = client.further_links().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::FurtherLinkCreate) -> Result<models::FurtherLink> {
let path = "/furtherlinks".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// `DELETE /furtherlinks/{furtherLinkId}`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.further_links().delete(1.5)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, further_link_id: impl Display) -> Result<()> {
let path = format!("/furtherlinks/{}", seg(further_link_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get further link.
///
/// `GET /furtherlinks/{furtherLinkId}`
///
/// Get the specified further link.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-furtherlinks-furtherLinkId");
/// let further_link = client.further_links().get(1.5)?;
/// println!("{}", further_link.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, further_link_id: impl Display) -> Result<models::FurtherLink> {
let path = format!("/furtherlinks/{}", seg(further_link_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get further links
///
/// `GET /furtherlinks`
///
/// Get all further links.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-furtherlinks");
/// for further_link in client.further_links().list()? {
/// println!("{}", further_link.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::FurtherLink>> {
let path = "/furtherlinks".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update further link
///
/// `PUT /furtherlinks/{furtherLinkId}`
///
/// Update the specified further link.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-furtherlinks-furtherLinkId");
/// let body = models::FurtherLinkCreate {
/// description: Some("Our church's NextCloud".into()),
/// image_url: Some("https://example.org".into()),
/// name: "NextCloud".into(),
/// sort_key: 1.5,
/// url: "https://example.org".into(),
/// ..Default::default()
/// };
/// let result = client.further_links().update(1.5, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, further_link_id: impl Display, body: &models::FurtherLinkCreate) -> Result<models::FurtherLink> {
let path = format!("/furtherlinks/{}", seg(further_link_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.group()`
#[derive(Clone, Copy)]
pub struct GroupResource<'a> {
client: &'a Client,
}
impl<'a> GroupResource<'a> {
pub fn age_groups(&self) -> GroupAgeGroupsResource<'a> {
GroupAgeGroupsResource { client: self.client }
}
pub fn group_categories(&self) -> GroupGroupCategoriesResource<'a> {
GroupGroupCategoriesResource { client: self.client }
}
pub fn group_types(&self) -> GroupGroupTypesResource<'a> {
GroupGroupTypesResource { client: self.client }
}
pub fn meeting_templates(&self) -> GroupMeetingTemplatesResource<'a> {
GroupMeetingTemplatesResource { client: self.client }
}
pub fn roles(&self) -> GroupRolesResource<'a> {
GroupRolesResource { client: self.client }
}
pub fn target_groups(&self) -> GroupTargetGroupsResource<'a> {
GroupTargetGroupsResource { client: self.client }
}
/// Get all group member statuses
///
/// `GET /group/memberstatus`
///
/// Returns the fixed membership-status values with their names translated into the current language. A status describes a person's membership state in a group; their role (for example leader or participant) is a separate property.
/// active means an active membership, requested a membership awaiting confirmation, waiting a place on the waiting list, and to_delete a membership pending removal. to_delete is still a stored membership state, not an already deleted record. These values are shared across group types. Use id in API requests and name for display.
/// Requires authentication. This endpoint takes no parameters and returns a plain array, without a data wrapper or meta object. It lists possible statuses, not the transitions that a particular user may perform for a particular membership.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-memberstatus");
/// for member_statu in client.group().list_member_status()? {
/// println!("{}", member_statu.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_member_status(&self) -> Result<Vec<models::GetGroupMemberstatusResponseItem>> {
let path = "/group/memberstatus".to_owned();
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
}
/// `client.group().age_groups()`
#[derive(Clone, Copy)]
pub struct GroupAgeGroupsResource<'a> {
client: &'a Client,
}
impl<'a> GroupAgeGroupsResource<'a> {
/// Create age range
///
/// `POST /group/agegroups`
///
/// Creates a age range as shared master data. An age range describes intended participant ages, such as ages 3 to 5. Groups can reference several ranges through information.ageGroupIds. These configured ranges are independent of the calculated ages of current members.
/// Requires the churchgroup permission "edit masterdata". Supply name, sortKey, start and end. Age boundaries are expressed in years. The name is trimmed. The endpoint validates integer boundaries but does not check that start is less than or equal to end; send a meaningful range. Returns the created record with its generated ID and translated display name. Creating this record does not create or assign any groups.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-group-agegroups");
/// let body = models::AgeGroupCreate {
/// end: 5,
/// name: "3-5".into(),
/// sort_key: 3,
/// start: 3,
/// ..Default::default()
/// };
/// let result = client.group().age_groups().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::AgeGroupCreate) -> Result<models::AgeGroup> {
let path = "/group/agegroups".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete age range
///
/// `DELETE /group/agegroups/{ageGroupId}`
///
/// Deletes a age range. Removing an age range also removes its ID from the ageGroupIds assignments of existing groups. The groups and their memberships remain.
/// Requires the churchgroup permission "edit masterdata". The dryRun query parameter is required: send false to delete or true to inspect the deletion report. A dry run changes no records and returns 409 with the report, even when deletion would be possible. An actual successful deletion returns 204 without a body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = DeleteGroupAgegroupsAgeGroupIdQuery {
/// dry_run: Some(true),
/// ..Default::default()
/// };
/// client.group().age_groups().delete(2, &query)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, age_group_id: impl Display, query: &DeleteGroupAgegroupsAgeGroupIdQuery) -> Result<()> {
let path = format!("/group/agegroups/{}", seg(age_group_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get age range
///
/// `GET /group/agegroups/{ageGroupId}`
///
/// Returns one age range using its ID from GET /group/agegroups. An age range describes intended participant ages, such as ages 3 to 5. Groups can reference several ranges through information.ageGroupIds. These configured ranges are independent of the calculated ages of current members.
/// Requires authentication, but no master-data editing permission. Returns a single object in data and no list metadata. Returns 404 when the record does not exist.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-agegroups-ageGroupId");
/// let age_group = client.group().age_groups().get(2)?;
/// println!("{}", age_group.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, age_group_id: impl Display) -> Result<models::AgeGroup> {
let path = format!("/group/agegroups/{}", seg(age_group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all age ranges
///
/// `GET /group/agegroups`
///
/// Returns all age ranges configured in this ChurchTools installation. An age range describes intended participant ages, such as ages 3 to 5. Groups can reference several ranges through information.ageGroupIds. These configured ranges are independent of the calculated ages of current members.
/// Requires authentication, but no master-data editing permission. There are no filter or pagination parameters. Results are ordered by sortKey ascending and then by the stored name ascending; meta.count is the number of returned records. IDs and labels are installation-specific; discover them before assigning them to groups.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-agegroups");
/// for age_group in client.group().age_groups().list()? {
/// println!("{}", age_group.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::AgeGroup>> {
let path = "/group/agegroups".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update age range
///
/// `PUT /group/agegroups/{ageGroupId}`
///
/// Updates the shared age range identified by ageGroupId. Existing group assignments continue to reference the same record. This is a full update, not a partial update.
/// Requires the churchgroup permission "edit masterdata". Supply name, sortKey, start and end. Age boundaries are expressed in years. The name is trimmed. The endpoint validates integer boundaries but does not check that start is less than or equal to end; send a meaningful range. The ID comes from the URL; no body id is required. Returns 204 without a response body. Use GET /group/agegroups/{ageGroupId} to read the updated record.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::AgeGroupCreate {
/// end: 5,
/// name: "3-5".into(),
/// sort_key: 3,
/// start: 3,
/// ..Default::default()
/// };
/// client.group().age_groups().update(2, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, age_group_id: impl Display, body: &models::AgeGroupCreate) -> Result<()> {
let path = format!("/group/agegroups/{}", seg(age_group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.group().group_categories()`
#[derive(Clone, Copy)]
pub struct GroupGroupCategoriesResource<'a> {
client: &'a Client,
}
impl<'a> GroupGroupCategoriesResource<'a> {
/// Create group category
///
/// `POST /group/groupcategories`
///
/// Creates a group category as shared master data. Categories organize groups by theme, for example worship services or community activities. A group references its category through information.groupCategoryId. Its group type separately defines shared settings and membership roles.
/// Requires the churchgroup permission "edit masterdata". Supply name, color and sortKey. description is optional; omitted, null or blank input is stored as null. Text fields are trimmed. Returns the created record with its generated ID and translated display name. Creating this record does not create or assign any groups.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-group-groupcategories");
/// let body = models::GroupCategoryCreate {
/// color: "blue".into(),
/// name: "Gottesdienst".into(),
/// sort_key: 5,
/// ..Default::default()
/// };
/// let result = client.group().group_categories().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::GroupCategoryCreate) -> Result<models::GroupCategory> {
let path = "/group/groupcategories".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete group category
///
/// `DELETE /group/groupcategories/{groupCategoryId}`
///
/// Deletes a group category. The deletion report includes groups that reference this category. Deleting a category does not delete these groups or their memberships.
/// Requires the churchgroup permission "edit masterdata". The dryRun query parameter is required: send false to delete or true to inspect the deletion report. A dry run changes no records and returns 409 with the report, even when deletion would be possible. An actual successful deletion returns 204 without a body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = DeleteGroupGroupcategoriesGroupCategoryIdQuery {
/// dry_run: Some(true),
/// ..Default::default()
/// };
/// client.group().group_categories().delete(2, &query)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_category_id: impl Display, query: &DeleteGroupGroupcategoriesGroupCategoryIdQuery) -> Result<()> {
let path = format!("/group/groupcategories/{}", seg(group_category_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get group category
///
/// `GET /group/groupcategories/{groupCategoryId}`
///
/// Returns one group category using its ID from GET /group/groupcategories. Categories organize groups by theme, for example worship services or community activities. A group references its category through information.groupCategoryId. Its group type separately defines shared settings and membership roles.
/// Requires authentication, but no master-data editing permission. Returns a single object in data and no list metadata. Returns 404 when the record does not exist.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-groupcategories-groupCategoryId");
/// let group_category = client.group().group_categories().get(2)?;
/// println!("{}", group_category.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_category_id: impl Display) -> Result<models::GroupCategory> {
let path = format!("/group/groupcategories/{}", seg(group_category_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all group categories
///
/// `GET /group/groupcategories`
///
/// Returns all group categories configured in this ChurchTools installation. Categories organize groups by theme, for example worship services or community activities. A group references its category through information.groupCategoryId. Its group type separately defines shared settings and membership roles.
/// Requires authentication, but no master-data editing permission. There are no filter or pagination parameters. Results are ordered by sortKey ascending and then by the stored name ascending; meta.count is the number of returned records. IDs and labels are installation-specific; discover them before assigning them to groups.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-groupcategories");
/// for group_category in client.group().group_categories().list()? {
/// println!("{}", group_category.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::GroupCategory>> {
let path = "/group/groupcategories".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update group category
///
/// `PUT /group/groupcategories/{groupCategoryId}`
///
/// Updates the shared group category identified by groupCategoryId. Existing group assignments continue to reference the same record. This is a full update, not a partial update.
/// Requires the churchgroup permission "edit masterdata". Supply name, color and sortKey. description is optional; omitted, null or blank input is stored as null. Text fields are trimmed. The ID comes from the URL; no body id is required. Returns the updated record in data.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-group-groupcategories-groupCategoryId");
/// let body = models::GroupCategoryCreate {
/// color: "blue".into(),
/// name: "Gottesdienst".into(),
/// sort_key: 5,
/// ..Default::default()
/// };
/// let result = client.group().group_categories().update(2, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, group_category_id: impl Display, body: &models::GroupCategoryCreate) -> Result<models::GroupCategory> {
let path = format!("/group/groupcategories/{}", seg(group_category_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.group().group_types()`
#[derive(Clone, Copy)]
pub struct GroupGroupTypesResource<'a> {
client: &'a Client,
}
impl<'a> GroupGroupTypesResource<'a> {
/// Create group type
///
/// `POST /group/grouptypes`
///
/// Creates a group type: shared configuration for groups such as small groups or ministry teams. This creates no groups or memberships. A participant role (the default) and a leader role are created automatically for the new type. Retrieve them with GET /group/roles?group_type_id={id} using the ID returned in data.id.
/// Requires the churchgroup permission "edit masterdata". Supply all required settings; the boolean fields do not have implicit request defaults. description is optional; omitted, null or blank descriptions are stored as null. Text fields are trimmed. Returns the created type with its generated ID, translated names and metadata.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-group-grouptypes");
/// let body = models::GroupTypeCreate {
/// available_for_new_person: false,
/// color: "blue".into(),
/// is_leader_necessary: false,
/// name: "Kleingruppe".into(),
/// name_plural: "Kleingruppen".into(),
/// permission_depth: 0,
/// posts_enabled: true,
/// shorty: "KG".into(),
/// sort_key: 2,
/// ..Default::default()
/// };
/// let result = client.group().group_types().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::GroupTypeCreate) -> Result<models::GroupType> {
let path = "/group/grouptypes".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete grouptype
///
/// `DELETE /group/grouptypes/{groupTypeId}`
///
/// Deletes a group type, including its role definitions, when no groups still reference it. Requires the churchgroup permission "edit masterdata". Existing groups block deletion; use a dry run to inspect references before making changes.
/// dryRun=true performs the deletion checks without deleting anything and returns a 409 deletion report even when deletion would be possible. A successful actual deletion returns 204 with no response body.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.group().group_types().delete(2)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_type_id: impl Display) -> Result<()> {
self.delete_with(group_type_id, &Default::default())
}
/// Delete grouptype
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /group/grouptypes/{groupTypeId}`
///
/// Deletes a group type, including its role definitions, when no groups still reference it. Requires the churchgroup permission "edit masterdata". Existing groups block deletion; use a dry run to inspect references before making changes.
/// dryRun=true performs the deletion checks without deleting anything and returns a 409 deletion report even when deletion would be possible. A successful actual deletion returns 204 with no response body.
pub fn delete_with(&self, group_type_id: impl Display, query: &DeleteGroupGrouptypesGroupTypeIdQuery) -> Result<()> {
let path = format!("/group/grouptypes/{}", seg(group_type_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get grouptype
///
/// `GET /group/grouptypes/{groupTypeId}`
///
/// Returns one group type by its installation-specific ID from GET /group/grouptypes. The result describes shared settings, not a concrete group. Use GET /group/roles with group_type_id to retrieve the role definitions belonging to this type. Requires authentication, but no master-data editing permission. Returns 404 when the type does not exist.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-grouptypes-groupTypeId");
/// let group_type = client.group().group_types().get(2)?;
/// println!("{}", group_type.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_type_id: impl Display) -> Result<models::GroupType> {
let path = format!("/group/grouptypes/{}", seg(group_type_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all group types
///
/// `GET /group/grouptypes`
///
/// Returns all group types configured in this ChurchTools installation. Group types are shared configuration records (master data), for example "Small group" or "Ministry team". A group is a concrete collection of people, such as "Tuesday evening small group", and references one type through `information.groupTypeId`.
/// Each type defines common settings and has its own membership roles, such as leader or participant. Use `GET /group/roles` to retrieve role definitions and match their `groupTypeId` to the type's `id`. Use `GET /groups` to retrieve actual groups; this endpoint does not return groups or their members.
/// Requires authentication. No master-data editing permission is required. The response is not paginated and accepts no filters. Results are ordered by `sortKey` ascending, then by the stored `name` ascending. `meta.count` is the number of group types returned. IDs and names are installation-specific; integrations should discover them instead of assuming fixed values.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-grouptypes");
/// for group_type in client.group().group_types().list()? {
/// println!("{}", group_type.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::GroupType>> {
let path = "/group/grouptypes".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update GroupType
///
/// `PUT /group/grouptypes/{groupTypeId}`
///
/// Updates the shared settings of a group type. Existing groups reference these settings; this endpoint does not create a group or change which type a group belongs to.
/// Requires the churchgroup permission "edit masterdata". Supply all required fields, including unchanged settings; this is not a partial update. The type ID comes from the URL, and no body id is required. Omitting description clears it to null rather than preserving the old text; null or blank text also clears it. Text fields are trimmed. Returns the updated type with translated names and metadata.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-group-grouptypes-groupTypeId");
/// let body = models::GroupTypeCreate {
/// available_for_new_person: false,
/// color: "blue".into(),
/// is_leader_necessary: false,
/// name: "Kleingruppe".into(),
/// name_plural: "Kleingruppen".into(),
/// permission_depth: 0,
/// posts_enabled: true,
/// shorty: "KG".into(),
/// sort_key: 2,
/// ..Default::default()
/// };
/// let result = client.group().group_types().update(2, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, group_type_id: impl Display, body: &models::GroupTypeCreate) -> Result<models::GroupType> {
let path = format!("/group/grouptypes/{}", seg(group_type_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.group().meeting_templates()`
#[derive(Clone, Copy)]
pub struct GroupMeetingTemplatesResource<'a> {
client: &'a Client,
}
impl<'a> GroupMeetingTemplatesResource<'a> {
/// Create group meeting feedback template
///
/// `POST /group/meetingtemplates`
///
/// Creates a reusable group-meeting feedback template. A template defines an ordered feedback form for group meetings. It is selected through settings.groupMeeting.templateId on a group. Meeting answers are stored separately in pollResult; the template does not schedule meetings or record attendance.
/// Requires the churchgroup permission "edit masterdata". Send name and the complete template array. Each field requires label and type. select fields also require non-empty options, preferably an array of non-blank strings; legacy comma-separated strings are accepted. Other field types must omit options or use null. An empty template array is allowed. Names and labels are trimmed. Returns the created template with its generated ID and metadata. Creating a template does not assign it to any groups.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-group-meetingtemplates");
/// let body = models::MeetingTemplateCreate {
/// name: "Lowlights / Highlights".into(),
/// template: vec![models::MeetingTemplateField {
/// label: "Highlights".into(),
/// r#type: "color".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.group().meeting_templates().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::MeetingTemplateCreate) -> Result<models::MeetingTemplate> {
let path = "/group/meetingtemplates".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete group meeting feedback template
///
/// `DELETE /group/meetingtemplates/{meetingTemplateId}`
///
/// Deletes a feedback template when no groups still reference it. Requires the churchgroup permission "edit masterdata". Groups using this template block deletion; change their template assignment before deleting it.
/// The dryRun query parameter is required. Send true to inspect deletion dependencies without changing records; the report is returned with 409 even when deletion would be possible. Send false to delete. Successful deletion returns 204 without a response body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = DeleteGroupMeetingtemplatesMeetingTemplateIdQuery {
/// dry_run: Some(true),
/// ..Default::default()
/// };
/// client.group().meeting_templates().delete(1, &query)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, meeting_template_id: impl Display, query: &DeleteGroupMeetingtemplatesMeetingTemplateIdQuery) -> Result<()> {
let path = format!("/group/meetingtemplates/{}", seg(meeting_template_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get group meeting feedback template
///
/// `GET /group/meetingtemplates/{meetingTemplateId}`
///
/// Returns one feedback template by its ID from GET /group/meetingtemplates. A template defines an ordered feedback form for group meetings. It is selected through settings.groupMeeting.templateId on a group. Meeting answers are stored separately in pollResult; the template does not schedule meetings or record attendance. Requires authentication, but no master-data editing permission. Returns the template in data, including its ordered fields and metadata. An unknown ID returns 404.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-meetingtemplates-meetingTemplateId");
/// let meeting_template = client.group().meeting_templates().get(1)?;
/// println!("{}", meeting_template.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, meeting_template_id: impl Display) -> Result<models::MeetingTemplate> {
let path = format!("/group/meetingtemplates/{}", seg(meeting_template_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all group meeting feedback templates
///
/// `GET /group/meetingtemplates`
///
/// Returns all configured group-meeting feedback templates. A template defines an ordered feedback form for group meetings. It is selected through settings.groupMeeting.templateId on a group. Meeting answers are stored separately in pollResult; the template does not schedule meetings or record attendance.
/// Requires authentication, but no master-data editing permission. Accepts no filter or pagination parameters. Results are sorted by name ascending. meta.count is the number of returned templates.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-meetingtemplates");
/// for meeting_template in client.group().meeting_templates().list()? {
/// println!("{}", meeting_template.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::MeetingTemplate>> {
let path = "/group/meetingtemplates".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update group meeting feedback template
///
/// `PUT /group/meetingtemplates/{meetingTemplateId}`
///
/// Replaces the name and complete field list of a feedback template. The template ID comes from the URL; no body id is required. Existing group assignments continue to reference this template.
/// Requires the churchgroup permission "edit masterdata". Send name and the complete template array. Each field requires label and type. select fields also require non-empty options, preferably an array of non-blank strings; legacy comma-separated strings are accepted. Other field types must omit options or use null. An empty template array is allowed. Names and labels are trimmed. Omitted fields in the array are removed from the template. Returns 204 without a response body; retrieve the template again to read its updated contents. When displaying existing feedback, the ChurchTools UI matches saved answers to template fields by label and type, so changing either can affect that display.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::MeetingTemplateCreate {
/// name: "Lowlights / Highlights".into(),
/// template: vec![models::MeetingTemplateField {
/// label: "Highlights".into(),
/// r#type: "color".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// client.group().meeting_templates().update(1, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, meeting_template_id: impl Display, body: &models::MeetingTemplateCreate) -> Result<()> {
let path = format!("/group/meetingtemplates/{}", seg(meeting_template_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.group().roles()`
#[derive(Clone, Copy)]
pub struct GroupRolesResource<'a> {
client: &'a Client,
}
impl<'a> GroupRolesResource<'a> {
/// Create Role
///
/// `POST /group/roles`
///
/// Creates a membership-role definition for the group type identified by groupTypeId. Groups of that type receive their own role settings records, which can be retrieved with GET /groups/{groupId}/roles. This does not add any people to a group.
/// Requires the churchgroup permission "edit masterdata". All listed required fields must be supplied, including growPathId (use null for no growth-path association). Setting isDefault to true removes the default flag from other roles of this type. Returns the created definition, including its generated ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-group-roles");
/// let body = models::RoleCreate {
/// group_type_id: 2,
/// grow_path_id: Some(4),
/// is_default: false,
/// is_hidden: false,
/// name: "Leiter".into(),
/// shorty: "L".into(),
/// sort_key: 1,
/// r#type: "leader".into(),
/// ..Default::default()
/// };
/// let result = client.group().roles().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::RoleCreate) -> Result<models::Role> {
let path = "/group/roles".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete role
///
/// `DELETE /group/roles/{roleId}`
///
/// Deletes a role definition and its group-specific settings, subject to deletion checks. Requires the churchgroup permission "edit masterdata". Another default role must remain for the same group type; otherwise the request fails with 400, including during a dry run. Set another role as default before deleting the current default.
/// Use dryRun=true to inspect deletion dependencies without deleting anything. A dry run returns 409 with the deletion report even when deletion would be possible. Actual successful deletion returns 204 with no response body.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.group().roles().delete(16)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, role_id: impl Display) -> Result<()> {
self.delete_with(role_id, &Default::default())
}
/// Delete role
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /group/roles/{roleId}`
///
/// Deletes a role definition and its group-specific settings, subject to deletion checks. Requires the churchgroup permission "edit masterdata". Another default role must remain for the same group type; otherwise the request fails with 400, including during a dry run. Set another role as default before deleting the current default.
/// Use dryRun=true to inspect deletion dependencies without deleting anything. A dry run returns 409 with the deletion report even when deletion would be possible. Actual successful deletion returns 204 with no response body.
pub fn delete_with(&self, role_id: impl Display, query: &DeleteGroupRolesRoleIdQuery) -> Result<()> {
let path = format!("/group/roles/{}", seg(role_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get role
///
/// `GET /group/roles/{roleId}`
///
/// Returns one membership-role definition by its ID from GET /group/roles. This is the definition belonging to a group type. For the settings of a role in an individual group, use GET /groups/{groupId}/roles instead. Requires authentication, but no master-data editing permission. Returns 404 when the role does not exist.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-roles-roleId");
/// let role = client.group().roles().get(16)?;
/// println!("{}", role.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, role_id: impl Display) -> Result<models::Role> {
let path = format!("/group/roles/{}", seg(role_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get roles
///
/// `GET /group/roles`
///
/// Returns membership-role definitions shared by groups of a given group type. For example, a small-group type may define leader, co-leader and participant roles. Use group_type_id to select one type; omitting it returns roles for all types. A type with no matching roles returns an empty data array.
/// The default standard format returns full Role objects. domainObject returns compact display references with a string domainIdentifier instead of the full role fields. Use GET /groups/{groupId}/roles for the settings of these roles in a specific group.
/// Requires authentication, but no master-data editing permission. The list is not paginated; meta.count is the number of returned roles. Without a filter, results are sorted by sortKey and name ascending. With group_type_id, they are sorted by type and sortKey ascending.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-roles");
/// let result = client.group().roles().list()?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<serde_json::Value> {
self.list_with(&Default::default())
}
/// Get roles
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /group/roles`
///
/// Returns membership-role definitions shared by groups of a given group type. For example, a small-group type may define leader, co-leader and participant roles. Use group_type_id to select one type; omitting it returns roles for all types. A type with no matching roles returns an empty data array.
/// The default standard format returns full Role objects. domainObject returns compact display references with a string domainIdentifier instead of the full role fields. Use GET /groups/{groupId}/roles for the settings of these roles in a specific group.
/// Requires authentication, but no master-data editing permission. The list is not paginated; meta.count is the number of returned roles. Without a filter, results are sorted by sortKey and name ascending. With group_type_id, they are sorted by type and sortKey ascending.
pub fn list_with(&self, query: &GetGroupRolesQuery) -> Result<serde_json::Value> {
let path = "/group/roles".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update Role
///
/// `PUT /group/roles/{roleId}`
///
/// Updates the shared role definition identified by roleId. Changes apply to the definition used by groups of its type; use PATCH /groups/{groupId}/roles/{roleId} to change settings for one group instead.
/// Requires the churchgroup permission "edit masterdata". Send all required fields; this is not a partial update. The ID is taken from the URL; no body id is required. groupTypeId is currently required by validation but does not move the role to another group type. Send the existing value.
/// Setting isDefault to true clears the default flag on other roles of the same type. Setting it to false is rejected with 400 if no other default role remains. Returns the updated definition.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-group-roles-roleId");
/// let body = models::RoleCreate {
/// group_type_id: 2,
/// grow_path_id: Some(4),
/// is_default: false,
/// is_hidden: false,
/// name: "Leiter".into(),
/// shorty: "L".into(),
/// sort_key: 1,
/// r#type: "leader".into(),
/// ..Default::default()
/// };
/// let result = client.group().roles().update(16, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, role_id: impl Display, body: &models::RoleCreate) -> Result<models::Role> {
let path = format!("/group/roles/{}", seg(role_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.group().target_groups()`
#[derive(Clone, Copy)]
pub struct GroupTargetGroupsResource<'a> {
client: &'a Client,
}
impl<'a> GroupTargetGroupsResource<'a> {
/// Create target audience
///
/// `POST /group/targetgroups`
///
/// Creates a target audience as shared master data. A target audience describes whom a group is intended for, such as families or students. A group references one audience through information.targetGroupId. This endpoint returns audience labels, not people or groups.
/// Requires the churchgroup permission "edit masterdata". Supply both name and sortKey. Use an integer sortKey to control display order. Returns the created record with its generated ID and translated display name. Creating this record does not create or assign any groups.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-group-targetgroups");
/// let body = models::TargetGroupCreate {
/// name: "men".into(),
/// sort_key: 2,
/// ..Default::default()
/// };
/// let result = client.group().target_groups().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::TargetGroupCreate) -> Result<models::TargetGroup> {
let path = "/group/targetgroups".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete target audience
///
/// `DELETE /group/targetgroups/{targetGroupId}`
///
/// Deletes a target audience. Deleting a target audience clears targetGroupId on groups assigned to it. The groups and their memberships remain.
/// Requires the churchgroup permission "edit masterdata". The dryRun query parameter is required: send false to delete or true to inspect the deletion report. A dry run changes no records and returns 409 with the report, even when deletion would be possible. An actual successful deletion returns 204 without a body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = DeleteGroupTargetgroupsTargetGroupIdQuery {
/// dry_run: Some(true),
/// ..Default::default()
/// };
/// client.group().target_groups().delete(2, &query)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, target_group_id: impl Display, query: &DeleteGroupTargetgroupsTargetGroupIdQuery) -> Result<()> {
let path = format!("/group/targetgroups/{}", seg(target_group_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get target audience
///
/// `GET /group/targetgroups/{targetGroupId}`
///
/// Returns one target audience using its ID from GET /group/targetgroups. A target audience describes whom a group is intended for, such as families or students. A group references one audience through information.targetGroupId. This endpoint returns audience labels, not people or groups.
/// Requires authentication, but no master-data editing permission. Returns a single object in data and no list metadata. Returns 404 when the record does not exist.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-targetgroups-targetGroupId");
/// let target_group = client.group().target_groups().get(2)?;
/// println!("{}", target_group.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, target_group_id: impl Display) -> Result<models::TargetGroup> {
let path = format!("/group/targetgroups/{}", seg(target_group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all target audiences
///
/// `GET /group/targetgroups`
///
/// Returns all target audiences configured in this ChurchTools installation. A target audience describes whom a group is intended for, such as families or students. A group references one audience through information.targetGroupId. This endpoint returns audience labels, not people or groups.
/// Requires authentication, but no master-data editing permission. There are no filter or pagination parameters. Results are ordered by sortKey ascending and then by the stored name ascending; meta.count is the number of returned records. IDs and labels are installation-specific; discover them before assigning them to groups.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-group-targetgroups");
/// for target_group in client.group().target_groups().list()? {
/// println!("{}", target_group.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::TargetGroup>> {
let path = "/group/targetgroups".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update target audience
///
/// `PUT /group/targetgroups/{targetGroupId}`
///
/// Updates the shared target audience identified by targetGroupId. Existing group assignments continue to reference the same record. This is a full update, not a partial update.
/// Requires the churchgroup permission "edit masterdata". Supply both name and sortKey. Use an integer sortKey to control display order. The ID comes from the URL; no body id is required. Returns 204 without a response body. Use GET /group/targetgroups/{targetGroupId} to read the updated record.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TargetGroupCreate {
/// name: "men".into(),
/// sort_key: 2,
/// ..Default::default()
/// };
/// client.group().target_groups().update(2, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, target_group_id: impl Display, body: &models::TargetGroupCreate) -> Result<()> {
let path = format!("/group/targetgroups/{}", seg(target_group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.group_homepages()`
#[derive(Clone, Copy)]
pub struct GroupHomepagesResource<'a> {
client: &'a Client,
}
impl<'a> GroupHomepagesResource<'a> {
/// Get a public group homepage by hash
///
/// `GET /grouphomepages/{hash}`
///
/// Public page settings, filter catalogs and eligible descendant groups for a group homepage hash. Anonymous access is supported, but signup eligibility and the public-group feature check can depend on whether the caller is signed in. Only enabled homepages are returned. Descendants are loaded through active, non-hidden hierarchy edges, sorted by the page’s configured field/direction, then filtered for public-page eligibility. The parent group itself is not included. An omitted depth uses the stored setting; depth=0 loads no groups, a positive depth limits hierarchy levels, and negative values currently traverse without a depth bound. The override does not change data.depth. Filter options include entire master-data catalogs, even for hidden filters and values unused by these groups. Group notes/places remain in the API even if their corresponding UI display settings hide them. No signup-person list is included here.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-grouphomepages-hash");
/// let group_homepage = client.group_homepages().get("RNdjTK0tGp1N1afoblczGbFb8ikLfa9b")?;
/// println!("{}", group_homepage.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, hash: impl Display) -> Result<models::GroupHomepage> {
self.get_with(hash, &Default::default())
}
/// Get a public group homepage by hash
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /grouphomepages/{hash}`
///
/// Public page settings, filter catalogs and eligible descendant groups for a group homepage hash. Anonymous access is supported, but signup eligibility and the public-group feature check can depend on whether the caller is signed in. Only enabled homepages are returned. Descendants are loaded through active, non-hidden hierarchy edges, sorted by the page’s configured field/direction, then filtered for public-page eligibility. The parent group itself is not included. An omitted depth uses the stored setting; depth=0 loads no groups, a positive depth limits hierarchy levels, and negative values currently traverse without a depth bound. The override does not change data.depth. Filter options include entire master-data catalogs, even for hidden filters and values unused by these groups. Group notes/places remain in the API even if their corresponding UI display settings hide them. No signup-person list is included here.
pub fn get_with(&self, hash: impl Display, query: &GetGrouphomepagesHashQuery) -> Result<models::GroupHomepage> {
let path = format!("/grouphomepages/{}", seg(hash));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all enabled group homepages
///
/// `GET /grouphomepages`
///
/// Public directory of every enabled group homepage as lightweight domain objects. No authentication or per-homepage view permission is required. The random page hashes are intentionally returned in apiUrl/frontendUrl and are not secrets suitable for access control. Entries include the owning parent group ID and hierarchy descendant IDs across all depths; this list does not apply the stored page depth or the detailed page’s public-group eligibility filter. Active, non-hidden hierarchy edges are followed, so child IDs can include internal groups and duplicates through multiple paths. There is no pagination or guaranteed ordering of homepage entries.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-grouphomepages");
/// for group_homepage in client.group_homepages().list()? {
/// println!("{}", group_homepage.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::DomainObjectGrouphomepage>> {
let path = "/grouphomepages".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.groups()`
#[derive(Clone, Copy)]
pub struct GroupsResource<'a> {
client: &'a Client,
}
impl<'a> GroupsResource<'a> {
pub fn checkin(&self) -> GroupsCheckinResource<'a> {
GroupsCheckinResource { client: self.client }
}
pub fn documents(&self) -> GroupsDocumentsResource<'a> {
GroupsDocumentsResource { client: self.client }
}
pub fn followups(&self) -> GroupsFollowupsResource<'a> {
GroupsFollowupsResource { client: self.client }
}
pub fn meetings(&self) -> GroupsMeetingsResource<'a> {
GroupsMeetingsResource { client: self.client }
}
pub fn member_fields(&self) -> GroupsMemberFieldsResource<'a> {
GroupsMemberFieldsResource { client: self.client }
}
pub fn members(&self) -> GroupsMembersResource<'a> {
GroupsMembersResource { client: self.client }
}
pub fn news_letter_integrations(&self) -> GroupsNewsLetterIntegrationsResource<'a> {
GroupsNewsLetterIntegrationsResource { client: self.client }
}
pub fn parents(&self) -> GroupsParentsResource<'a> {
GroupsParentsResource { client: self.client }
}
pub fn qrcode_checkin(&self) -> GroupsQrcodeCheckinResource<'a> {
GroupsQrcodeCheckinResource { client: self.client }
}
pub fn roles(&self) -> GroupsRolesResource<'a> {
GroupsRolesResource { client: self.client }
}
pub fn wiki(&self) -> GroupsWikiResource<'a> {
GroupsWikiResource { client: self.client }
}
/// Start or stop an event chat
///
/// `POST /groups/{groupId}/chat`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::StartStopChat {
/// enabled: true,
/// ..Default::default()
/// };
/// client.groups().chat(42, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn chat(&self, group_id: impl Display, body: &models::StartStopChat) -> Result<()> {
let path = format!("/groups/{}/chat", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Create Group
///
/// `POST /groups`
///
/// Create new group
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-groups");
/// let body = models::PostGroupsBody {
/// group_status_id: 1,
/// group_type_id: 42,
/// name: "Hauskreis Nord".into(),
/// ..Default::default()
/// };
/// let result = client.groups().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::PostGroupsBody) -> Result<models::Group> {
let path = "/groups".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a group
///
/// `DELETE /groups/{groupId}`
///
/// Delete a group. This will remove all people from this group.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().delete(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_id: impl Display) -> Result<()> {
self.delete_with(group_id, &Default::default())
}
/// Delete a group
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /groups/{groupId}`
///
/// Delete a group. This will remove all people from this group.
pub fn delete_with(&self, group_id: impl Display, query: &DeleteGroupsGroupIdQuery) -> Result<()> {
let path = format!("/groups/{}", seg(group_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Delete a group’s homepage configuration
///
/// `DELETE /groups/{groupId}/grouphomepage`
///
/// Permanently removes the homepage configuration attached to this parent group, including its public URL hash. The group, child groups and their memberships are retained. Requires permission to edit the parent group’s basic settings. If that group has no homepage configuration, the request still returns 204. There is no delete-preview workflow; use PUT with isEnabled=false to keep the configuration while disabling the public page.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().delete_group_homepage(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_group_homepage(&self, group_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/grouphomepage", seg(group_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Duplicate a group with selected related data
///
/// `POST /groups/{groupId}/duplicate`
///
/// Creates a pending group with a new ID, GUID and name. Requires permission to create a group with the source group’s type, campus and parent groups. The copy includes both parent and child hierarchy links, tags, membership field definitions, role settings, addresses and the group image. Memberships, role permissions and membership routines are copied only when their flags are enabled. Meetings and the appointment link are cleared. An existing group homepage is cloned with a new URL hash. Supply newName and optional flags in the query or JSON body; query values take precedence. The returned group is not enriched with all copied related data.
///
/// Use [`Self::duplicate_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-groups-id-duplicate");
/// let body = models::GroupDuplicateCreate {
/// copy_members: Some(true),
/// ..Default::default()
/// };
/// let group = client.groups().duplicate(42, &body)?;
/// println!("{}", group.name);
/// # Ok(())
/// # }
/// ```
pub fn duplicate(&self, group_id: impl Display, body: &models::GroupDuplicateCreate) -> Result<models::Group> {
self.duplicate_with(group_id, &Default::default(), body)
}
/// Duplicate a group with selected related data
///
/// Like [`Self::duplicate`], with query parameters.
///
/// `POST /groups/{groupId}/duplicate`
///
/// Creates a pending group with a new ID, GUID and name. Requires permission to create a group with the source group’s type, campus and parent groups. The copy includes both parent and child hierarchy links, tags, membership field definitions, role settings, addresses and the group image. Memberships, role permissions and membership routines are copied only when their flags are enabled. Meetings and the appointment link are cleared. An existing group homepage is cloned with a new URL hash. Supply newName and optional flags in the query or JSON body; query values take precedence. The returned group is not enriched with all copied related data.
pub fn duplicate_with(&self, group_id: impl Display, query: &PostGroupsIdDuplicateQuery, body: &models::GroupDuplicateCreate) -> Result<models::Group> {
let path = format!("/groups/{}/duplicate", seg(group_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Export groups
///
/// `POST /groups/export`
///
/// Downloads selected visible groups as a spreadsheet, sorted by group name. Unknown or invisible IDs are omitted; an empty ids array produces a header-only export. Columns include standard and custom group fields, registration availability, tags, membership statistics, places and direct parent/child groups. Field labels and formatted values use the current language. Group field values pass through field security checks; related groups that are not visible may still appear as bare IDs. CSV uses semicolon-separated UTF-8 text; XLSX returns a workbook. This read-only POST does not create a stored file and does not paginate.
///
/// Use [`Self::export_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::GroupExportCreate {
/// ids: vec![12, 34],
/// ..Default::default()
/// };
/// let data = client.groups().export(&body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn export(&self, body: &models::GroupExportCreate) -> Result<Vec<u8>> {
self.export_with(&Default::default(), body)
}
/// Export groups
///
/// Like [`Self::export`], with query parameters.
///
/// `POST /groups/export`
///
/// Downloads selected visible groups as a spreadsheet, sorted by group name. Unknown or invisible IDs are omitted; an empty ids array produces a header-only export. Columns include standard and custom group fields, registration availability, tags, membership statistics, places and direct parent/child groups. Field labels and formatted values use the current language. Group field values pass through field security checks; related groups that are not visible may still appear as bare IDs. CSV uses semicolon-separated UTF-8 text; XLSX returns a workbook. This read-only POST does not create a stored file and does not paginate.
pub fn export_with(&self, query: &PostGroupsExportQuery, body: &models::GroupExportCreate) -> Result<Vec<u8>> {
let path = "/groups/export".to_owned();
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
/// Get a group
///
/// `GET /groups/{groupId}`
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId");
/// let group = client.groups().get(42)?;
/// println!("{}", group.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_id: impl Display) -> Result<models::Group> {
self.get_with(group_id, &Default::default())
}
/// Get a group
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /groups/{groupId}`
pub fn get_with(&self, group_id: impl Display, query: &GetGroupsGroupIdQuery) -> Result<models::Group> {
let path = format!("/groups/{}", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get a group’s homepage configuration
///
/// `GET /groups/{groupId}/grouphomepage`
///
/// Returns the homepage configuration attached to this parent group, including disabled homepages. Requires permission to edit the parent group’s basic settings; ordinary group visibility is insufficient. A group without a homepage returns 404. This settings lookup does not populate the child groups or filter option catalogs: groups is empty and filter entries omit options. For the public page with its child groups and catalogs, use GET /grouphomepages/{hash}. showMap is combined with the global OpenStreetMap setting, so it can be false even when the stored page flag is true.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-grouphomepage");
/// let group_homepage = client.groups().get_group_homepage(42)?;
/// println!("{}", group_homepage.name);
/// # Ok(())
/// # }
/// ```
pub fn get_group_homepage(&self, group_id: impl Display) -> Result<models::GroupHomepage> {
let path = format!("/groups/{}/grouphomepage", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get grouped groups
///
/// `GET /groups/grouped`
///
/// Returns visible groups grouped by the requested group attribute. Each group contains a preview list limited by `limit` and the total number of matching groups in `all`.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-grouped");
/// let query = GetGroupsGroupedQuery {
/// group_by: Some("ageGroup".into()),
/// ..Default::default()
/// };
/// let grouped = client.groups().get_grouped(&query)?;
/// println!("{}", grouped.grouped_by);
/// # Ok(())
/// # }
/// ```
pub fn get_grouped(&self, query: &GetGroupsGroupedQuery) -> Result<models::GroupedGroups> {
let path = "/groups/grouped".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get stored newsletter consent and synchronization states
///
/// `GET /groups/{groupId}/optins`
///
/// Returns active newsletter mappings and local newsletter-person records for the group, keyed by provider:listId and person ID. Requires permission to view the group and its members. The current backend calls the global administer groups check but does not enforce its result. Disabled/unknown providers are absent from newsletter; person records can remain with empty newsletter maps. The data is unpaginated, has no meta envelope and is not a live provider status lookup. Empty maps serialize as \[\].
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-optins");
/// let optin = client.groups().get_optins(42)?;
/// println!("{:?}", optin);
/// # Ok(())
/// # }
/// ```
pub fn get_optins(&self, group_id: impl Display) -> Result<models::NewsletterOptInData> {
let path = format!("/groups/{}/optins", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Count published group posts by visibility
///
/// `GET /groups/{groupId}/poststatistics`
///
/// Returns one object containing counts for group_intern and group_visible. Only already published, unexpired and non-banned posts are counted, and posts must be enabled for both the group and its group type. Drafts/scheduled posts are excluded. Empty groups and groups with posts disabled return both counters as zero. The current handler requires authentication but ignores the result of its group-edit permission check and does not filter counts by the caller’s post visibility. The response has no pagination or meta.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-poststatistics");
/// let post_statistic = client.groups().get_post_statistics(42)?;
/// println!("{}", post_statistic.group_intern);
/// # Ok(())
/// # }
/// ```
pub fn get_post_statistics(&self, group_id: impl Display) -> Result<models::GroupPostStatistics> {
let path = format!("/groups/{}/poststatistics", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get group capacity and visible membership counts
///
/// `GET /groups/{groupId}/statistics`
///
/// Returns one statistics object for the group. Requires group visibility. members is a role/status histogram restricted to members and persons visible to the caller; unfiltered contains group-wide capacity counts regardless of individual visibility. Consequently, summing members need not match any unfiltered counter. Roles, workflow status, archive state and seat-counting settings affect the counters differently. A group without visible memberships returns members=\[\]; capacity counters are still present. The response is not paginated and has no meta envelope.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-id-statistics");
/// let statistic = client.groups().get_statistics(42)?;
/// println!("{:?}", statistic);
/// # Ok(())
/// # }
/// ```
pub fn get_statistics(&self, group_id: impl Display) -> Result<models::GroupStatistics> {
let path = format!("/groups/{}/statistics", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Change a group’s type and migrate its roles
///
/// `POST /groups/{groupId}/grouptype`
///
/// Changes the group type and applies the supplied role mapping within a database transaction. Requires permission to edit the groupTypeId field of this group. Membership roles, group-role settings and their permissions, the registration override role, membership routines, dynamic-group rules and website role references can be affected. New target-type roles receive default group settings; obsolete role settings and their permissions are removed. Provide a complete mapping from old to new group-type role IDs. Use a different target type with valid target roles; incomplete or inconsistent mappings can fail during migration or leave membership roles inconsistent. Success returns 204 without a response body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::GroupTypeChangeUpdate {
/// group_type_id: 3,
/// role_mapping: Default::default(),
/// ..Default::default()
/// };
/// client.groups().group_type(42, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn group_type(&self, group_id: impl Display, body: &models::GroupTypeChangeUpdate) -> Result<()> {
let path = format!("/groups/{}/grouptype", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Get all groups
///
/// `GET /groups`
///
/// This endpoint returns an array with all groups the user can see. This includes groups the user
/// is a member of as well as subordinate groups the user is allowed to see.
/// In addition to the documented query parameters, groups can be filtered by all group fields (`=fieldValue`) as query parameters. For group fields with options (e.g. select fields), the format would be `[]=optionId` and can be repeated for serveral ids.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups");
/// for group in client.groups().list()? {
/// println!("{}", group.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Group>> {
self.list_with(&Default::default())
}
/// Get all groups
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /groups`
///
/// This endpoint returns an array with all groups the user can see. This includes groups the user
/// is a member of as well as subordinate groups the user is allowed to see.
/// In addition to the documented query parameters, groups can be filtered by all group fields (`=fieldValue`) as query parameters. For group fields with options (e.g. select fields), the format would be `[]=optionId` and can be repeated for serveral ids.
pub fn list_with(&self, query: &GetGroupsQuery) -> Result<Vec<models::Group>> {
let path = "/groups".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all groups
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetGroupsQuery) -> Items<models::Group> {
let path = "/groups".to_owned();
self.client.items(&path, query.to_query())
}
/// Fetch all absences for persons in a group
///
/// `GET /groups/{groupId}/absences`
///
/// Returns absences for active, visible group members. Requires access to the group; member results are additionally restricted by manage absent or the internal group permission to view absences. Returns absences whose start is at or before to and whose end is at or after from. Absences ending exactly at midnight on the from date are also included, even if from specifies a later time that day. Dates use the application time zone; UTC timestamps are converted into it. Without filters the window starts at midnight two weeks ago and ends at midnight two weeks from today. The list is unpaginated and sorted by start; meta.count is the number returned.
///
/// Use [`Self::list_absences_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-absences");
/// for absence in client.groups().list_absences(42)? {
/// println!("{}", absence.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_absences(&self, group_id: impl Display) -> Result<Vec<models::Absence>> {
self.list_absences_with(group_id, &Default::default())
}
/// Fetch all absences for persons in a group
///
/// Like [`Self::list_absences`], with query parameters.
///
/// `GET /groups/{groupId}/absences`
///
/// Returns absences for active, visible group members. Requires access to the group; member results are additionally restricted by manage absent or the internal group permission to view absences. Returns absences whose start is at or before to and whose end is at or after from. Absences ending exactly at midnight on the from date are also included, even if from specifies a later time that day. Dates use the application time zone; UTC timestamps are converted into it. Without filters the window starts at midnight two weeks ago and ends at midnight two weeks from today. The list is unpaginated and sorted by start; meta.count is the number returned.
pub fn list_absences_with(&self, group_id: impl Display, query: &GetGroupsAbsencesQuery) -> Result<Vec<models::Absence>> {
let path = format!("/groups/{}/absences", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get child groups
///
/// `GET /groups/{groupId}/children`
///
/// Use [`Self::list_children_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-children");
/// for children in client.groups().list_children(42)? {
/// println!("{}", children.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_children(&self, group_id: impl Display) -> Result<Vec<models::DomainObjectGroup>> {
self.list_children_with(group_id, &Default::default())
}
/// Get child groups
///
/// Like [`Self::list_children`], with query parameters.
///
/// `GET /groups/{groupId}/children`
pub fn list_children_with(&self, group_id: impl Display, query: &GetGroupsGroupIdChildrenQuery) -> Result<Vec<models::DomainObjectGroup>> {
let path = format!("/groups/{}/children", seg(group_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get child groups
///
/// Like [`Self::list_children_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_children_iter(&self, group_id: impl Display, query: &GetGroupsGroupIdChildrenQuery) -> Items<models::DomainObjectGroup> {
let path = format!("/groups/{}/children", seg(group_id));
self.client.items(&path, query.to_query())
}
/// List membership document templates for the current user
///
/// `GET /groups/{groupId}/documenttemplates`
///
/// Lists the document templates assigned to the current user’s role in this group. The current user must have an active membership and that role must be configured in the group; administrative rights do not replace that membership. The result follows the role’s configured template order and is not paginated. An empty list means the role has no assigned templates. This endpoint returns template names only and does not generate PDFs. Unlike document generation, it does not check whether the group itself is active, so a listed template may still be unavailable for download.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-documenttemplates");
/// for document_template in client.groups().list_document_templates(42)? {
/// println!("{}", document_template.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_document_templates(&self, group_id: impl Display) -> Result<Vec<models::HtmlTemplateInfo>> {
let path = format!("/groups/{}/documenttemplates", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all group hierarchies
///
/// `GET /groups/hierarchies`
///
/// Returns all group hierarchies. The groups not visible for the user only show ids. Note: You have to pass at least 2 group IDs for the filter to work. If you only want to see the children of a specific group use `GET /groups/{groupId}/children`.
///
/// Use [`Self::list_hierarchies_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-hierarchies");
/// for hierarchy in client.groups().list_hierarchies()? {
/// println!("{}", hierarchy.group_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_hierarchies(&self) -> Result<Vec<models::GroupHierarchy>> {
self.list_hierarchies_with(&Default::default())
}
/// Get all group hierarchies
///
/// Like [`Self::list_hierarchies`], with query parameters.
///
/// `GET /groups/hierarchies`
///
/// Returns all group hierarchies. The groups not visible for the user only show ids. Note: You have to pass at least 2 group IDs for the filter to work. If you only want to see the children of a specific group use `GET /groups/{groupId}/children`.
pub fn list_hierarchies_with(&self, query: &GetGroupsHierarchiesQuery) -> Result<Vec<models::GroupHierarchy>> {
let path = "/groups/hierarchies".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all group hierarchies
///
/// Like [`Self::list_hierarchies_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_hierarchies_iter(&self, query: &GetGroupsHierarchiesQuery) -> Items<models::GroupHierarchy> {
let path = "/groups/hierarchies".to_owned();
self.client.items(&path, query.to_query())
}
/// Get all group ids
///
/// `GET /groups/ids`
///
/// Returns all group ids the user can see. This includes groups the user is a member of as well as subordinate groups the user is allowed to see. Same as `GET /groups` but only returns ids.
///
/// Use [`Self::list_ids_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-ids");
/// for id in client.groups().list_ids()? {
/// println!("{:?}", id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_ids(&self) -> Result<Vec<i64>> {
self.list_ids_with(&Default::default())
}
/// Get all group ids
///
/// Like [`Self::list_ids`], with query parameters.
///
/// `GET /groups/ids`
///
/// Returns all group ids the user can see. This includes groups the user is a member of as well as subordinate groups the user is allowed to see. Same as `GET /groups` but only returns ids.
pub fn list_ids_with(&self, query: &GetGroupsIdsQuery) -> Result<Vec<i64>> {
let path = "/groups/ids".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all group ids
///
/// Like [`Self::list_ids_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_ids_iter(&self, query: &GetGroupsIdsQuery) -> Items<i64> {
let path = "/groups/ids".to_owned();
self.client.items(&path, query.to_query())
}
/// Get person IDs of group members
///
/// `GET /groups/{groupId}/memberids`
///
/// Returns the person IDs of all visible memberships matching the filters. These IDs can be used as personId in /groups/{groupId}/members/{personId}; they are not membership record IDs. Results are not paginated, and meta.count is the number of returned IDs. Filters are combined, and visibility restrictions still apply. Additional filters can use a group member field’s reference name or display name (=fieldValue), or a person-field key (person_=fieldValue).
///
/// Use [`Self::list_member_ids_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-memberids");
/// for member_id in client.groups().list_member_ids(42)? {
/// println!("{:?}", member_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_member_ids(&self, group_id: impl Display) -> Result<Vec<i64>> {
self.list_member_ids_with(group_id, &Default::default())
}
/// Get person IDs of group members
///
/// Like [`Self::list_member_ids`], with query parameters.
///
/// `GET /groups/{groupId}/memberids`
///
/// Returns the person IDs of all visible memberships matching the filters. These IDs can be used as personId in /groups/{groupId}/members/{personId}; they are not membership record IDs. Results are not paginated, and meta.count is the number of returned IDs. Filters are combined, and visibility restrictions still apply. Additional filters can use a group member field’s reference name or display name (=fieldValue), or a person-field key (person_=fieldValue).
pub fn list_member_ids_with(&self, group_id: impl Display, query: &GetGroupsGroupIdMemberidsQuery) -> Result<Vec<i64>> {
let path = format!("/groups/{}/memberids", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Preview active group members by role
///
/// `GET /groups/{groupId}/memberpreview`
///
/// Returns each role of the group’s group type with a limited selection of active, visible members. Roles are ordered by type and sort key, including roles with no matching members. Within each role, persons with an avatar come first, followed by last name and first name. members_per_role limits each role separately; meta.count counts role entries, not members. Use GET /groups/{groupId}/members for the paginated membership list and additional fields.
///
/// Use [`Self::list_member_preview_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-memberpreview");
/// for member_preview in client.groups().list_member_preview(42)? {
/// println!("{:?}", member_preview);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_member_preview(&self, group_id: impl Display) -> Result<Vec<models::MemberPreview>> {
self.list_member_preview_with(group_id, &Default::default())
}
/// Preview active group members by role
///
/// Like [`Self::list_member_preview`], with query parameters.
///
/// `GET /groups/{groupId}/memberpreview`
///
/// Returns each role of the group’s group type with a limited selection of active, visible members. Roles are ordered by type and sort key, including roles with no matching members. Within each role, persons with an avatar come first, followed by last name and first name. members_per_role limits each role separately; meta.count counts role entries, not members. Use GET /groups/{groupId}/members for the paginated membership list and additional fields.
pub fn list_member_preview_with(&self, group_id: impl Display, query: &GetGroupsGroupIdMemberpreviewQuery) -> Result<Vec<models::MemberPreview>> {
let path = format!("/groups/{}/memberpreview", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all group members
///
/// `GET /groups/members`
///
/// Returns all group members. Only accessible for users with right "administer persons".
///
/// Use [`Self::list_members_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-members");
/// for member in client.groups().list_members()? {
/// println!("{}", member.deleted);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_members(&self) -> Result<Vec<models::GroupMemberShort>> {
self.list_members_with(&Default::default())
}
/// Get all group members
///
/// Like [`Self::list_members`], with query parameters.
///
/// `GET /groups/members`
///
/// Returns all group members. Only accessible for users with right "administer persons".
pub fn list_members_with(&self, query: &GetGroupsMembersQuery) -> Result<Vec<models::GroupMemberShort>> {
let path = "/groups/members".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get visible posts of a group
///
/// `GET /groups/{groupId}/posts`
///
/// Returns published, unexpired and unbanned local posts visible to the current user in this group. Anonymous access is supported and limited by public group and post visibility. Posts must be enabled for both the group and its group type. Group-internal posts require membership; other posts follow group visibility. A missing or inaccessible group returns an empty list. Explicitly selecting a group includes it even when the user has hidden the group from their feed; hidden posts and hidden authors remain excluded. External instances are not queried. Results are ordered by publishedDate and GUID descending. For the next batch, pass the last post’s publishedDate as before and its guid as last_post_identifier. page is ignored; pagination.current stays 1, and total/lastPage describe the remaining cursor-filtered results rather than the complete feed.
///
/// Use [`Self::list_posts_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-posts");
/// for post in client.groups().list_posts(42)? {
/// println!("{}", post.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_posts(&self, group_id: impl Display) -> Result<Vec<models::Post>> {
self.list_posts_with(group_id, &Default::default())
}
/// Get visible posts of a group
///
/// Like [`Self::list_posts`], with query parameters.
///
/// `GET /groups/{groupId}/posts`
///
/// Returns published, unexpired and unbanned local posts visible to the current user in this group. Anonymous access is supported and limited by public group and post visibility. Posts must be enabled for both the group and its group type. Group-internal posts require membership; other posts follow group visibility. A missing or inaccessible group returns an empty list. Explicitly selecting a group includes it even when the user has hidden the group from their feed; hidden posts and hidden authors remain excluded. External instances are not queried. Results are ordered by publishedDate and GUID descending. For the next batch, pass the last post’s publishedDate as before and its guid as last_post_identifier. page is ignored; pagination.current stays 1, and total/lastPage describe the remaining cursor-filtered results rather than the complete feed.
pub fn list_posts_with(&self, group_id: impl Display, query: &GetGroupsGroupIdPostsQuery) -> Result<Vec<models::Post>> {
let path = format!("/groups/{}/posts", seg(group_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get visible posts of a group
///
/// Like [`Self::list_posts_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_posts_iter(&self, group_id: impl Display, query: &GetGroupsGroupIdPostsQuery) -> Items<models::Post> {
let path = format!("/groups/{}/posts", seg(group_id));
self.client.items(&path, query.to_query())
}
/// Send a group sign-up push notification
///
/// `POST /groups/{groupId}/notification`
///
/// Announces a group to potential new members through push notifications. Requires permission to edit the group’s basic settings. Recipients have registered push devices, are not already linked to the group, and have not disabled these notifications. Group age, target-group and category values are compared with notification preferences, not with a person’s age or memberships. Use dry_run to preview the selection count without sending or marking the group as notified. A normal request marks the group as notified even when the count is zero; later requests, including dry runs, return 403. sentToCount measures recipient selection, not successful delivery. The response is returned directly without a data wrapper.
///
/// Use [`Self::notification_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::GroupSignUpNotificationRequest {
/// dry_run: Some(true),
/// ..Default::default()
/// };
/// let group = client.groups().notification(42, &body)?;
/// println!("{}", group.sent_to_count);
/// # Ok(())
/// # }
/// ```
pub fn notification(&self, group_id: impl Display, body: &models::GroupSignUpNotificationRequest) -> Result<models::GroupSignUpNotificationResult> {
self.notification_with(group_id, &Default::default(), body)
}
/// Send a group sign-up push notification
///
/// Like [`Self::notification`], with query parameters.
///
/// `POST /groups/{groupId}/notification`
///
/// Announces a group to potential new members through push notifications. Requires permission to edit the group’s basic settings. Recipients have registered push devices, are not already linked to the group, and have not disabled these notifications. Group age, target-group and category values are compared with notification preferences, not with a person’s age or memberships. Use dry_run to preview the selection count without sending or marking the group as notified. A normal request marks the group as notified even when the count is zero; later requests, including dry runs, return 403. sentToCount measures recipient selection, not successful delivery. The response is returned directly without a data wrapper.
pub fn notification_with(&self, group_id: impl Display, query: &PostGroupsGroupIdNotificationQuery, body: &models::GroupSignUpNotificationRequest) -> Result<models::GroupSignUpNotificationResult> {
let path = format!("/groups/{}/notification", seg(group_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
/// Update Group
///
/// `PATCH /groups/{groupId}`
///
/// Update a group by id. All group fields can be updated here. Use the fields api to get all fields that can be updated here. To link an existing group to an existing appointment (e.g. a sign-up group), set `appointmentId` (and optionally `startDate` to identify a specific occurrence of a repeating appointment). Set `appointmentId` to `null` to remove the link. The current user must have permission to edit both the group and the referenced appointment.
///
/// Use [`Self::patch_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("patch-groups-id");
/// let body = models::PatchGroupsIdBody {
/// appointment_id: Some(Some(42)),
/// ..Default::default()
/// };
/// let result = client.groups().patch(42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, group_id: impl Display, body: &models::PatchGroupsIdBody) -> Result<models::Group> {
self.patch_with(group_id, &Default::default(), body)
}
/// Update Group
///
/// Like [`Self::patch`], with query parameters.
///
/// `PATCH /groups/{groupId}`
///
/// Update a group by id. All group fields can be updated here. Use the fields api to get all fields that can be updated here. To link an existing group to an existing appointment (e.g. a sign-up group), set `appointmentId` (and optionally `startDate` to identify a specific occurrence of a repeating appointment). Set `appointmentId` to `null` to remove the link. The current user must have permission to edit both the group and the referenced appointment.
pub fn patch_with(&self, group_id: impl Display, query: &PatchGroupsIdQuery, body: &models::PatchGroupsIdBody) -> Result<models::Group> {
let path = format!("/groups/{}", seg(group_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
/// Create or update a group’s homepage configuration
///
/// `PUT /groups/{groupId}/grouphomepage`
///
/// Creates the homepage configuration if none exists, otherwise updates it. Requires permission to edit the parent group’s basic settings. Existing URL hashes are preserved; newly created pages receive a random hash. Supply all five enabled/display flags. Omitted header modes and custom text preserve existing values; omitted layout, ordering, collapse and depth settings reset to defaults, and omitted filters disables all filters. Returns 200 with an empty JSON object for both create and update. Read GET /groups/{groupId}/grouphomepage afterwards to obtain the saved configuration and URL hash.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-groups-groupId-grouphomepage");
/// let body = models::GroupHomepageUpdate {
/// is_enabled: true,
/// show_filters: true,
/// show_group_images: true,
/// show_leaders: true,
/// show_map: true,
/// ..Default::default()
/// };
/// let result = client.groups().update_group_homepage(42, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update_group_homepage(&self, group_id: impl Display, body: &models::GroupHomepageUpdate) -> Result<std::collections::BTreeMap<String, serde_json::Value>> {
let path = format!("/groups/{}/grouphomepage", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Put, &path, &query, Some(&body))
}
}
/// `client.groups().checkin()`
#[derive(Clone, Copy)]
pub struct GroupsCheckinResource<'a> {
client: &'a Client,
}
impl<'a> GroupsCheckinResource<'a> {
/// Check in a person at a group meeting
///
/// `POST /groups/{groupId}/checkin/{personId}`
///
/// Marks an existing person present at a group meeting. Requires permission to manage meetings of the path group. Supply either an existing meeting ID belonging to this group or its exact start timestamp; the timestamp variant creates a meeting when necessary. This does not create a group membership. Completed meetings and people already marked present produce 400. An optional ticket is marked used before these checks. printerId requests a name tag; printer warnings do not undo attendance or prevent a success response.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::CheckinCreate {
/// date: Some(Some("2022-10-19T12:00:00Z".parse()?)),
/// ..Default::default()
/// };
/// let result = client.groups().checkin().create(42, 42, &body)?;
/// println!("{}", result.total_checked_in);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, group_id: impl Display, person_id: impl Display, body: &models::CheckinCreate) -> Result<models::Checkin> {
let path = format!("/groups/{}/checkin/{}", seg(group_id), seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.groups().documents()`
#[derive(Clone, Copy)]
pub struct GroupsDocumentsResource<'a> {
client: &'a Client,
}
impl<'a> GroupsDocumentsResource<'a> {
/// `GET /groups/{groupId}/documents/{htmlTemplateId}`
///
/// Get a group document for the current logged in User
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().documents().get(42, "abc123")?;
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_id: impl Display, html_template_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/documents/{}", seg(group_id), seg(html_template_id));
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
}
/// `client.groups().followups()`
#[derive(Clone, Copy)]
pub struct GroupsFollowupsResource<'a> {
client: &'a Client,
}
impl<'a> GroupsFollowupsResource<'a> {
/// Count follow-ups for a group by due state
///
/// `GET /groups/{groupId}/followups/statistics`
///
/// Counts follow-ups in this group assigned to the current user, plus unassigned follow-ups where that user has group follow-up rights. Items assigned to other people and archived subject persons are excluded, matching the group list scope. Requires permission to administer or perform follow-ups in this group. The counters cover all matching records and ignore list pagination and filter parameters. Due states use the effective due date and the server’s current date; dismissed and completed follow-ups share countDone. An empty scope returns all five counters as zero.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-followups-statistics");
/// let statistic = client.groups().followups().get_statistics(42)?;
/// println!("{}", statistic.count_done);
/// # Ok(())
/// # }
/// ```
pub fn get_statistics(&self, group_id: impl Display) -> Result<models::FollowUpStatistics> {
let path = format!("/groups/{}/followups/statistics", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List follow-ups for group memberships
///
/// `GET /groups/{groupId}/followups`
///
/// Returns follow-ups associated with this group, restricted to items assigned to the current user and unassigned items in groups where that user has follow-up rights. Items assigned to other people are omitted even if the current user can view them individually. Requires permission to administer or perform follow-ups in this group. Follow-ups whose subject person is archived are excluded. State filters are combined with OR; omission includes all states. Results are ordered by completion date descending, effective due date ascending, then ID. Pagination returns only meta.count for this page, without a total or last-page value.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-followups");
/// for followup in client.groups().followups().list(42)? {
/// println!("{}", followup.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display) -> Result<Vec<models::FollowUp2>> {
self.list_with(group_id, &Default::default())
}
/// List follow-ups for group memberships
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /groups/{groupId}/followups`
///
/// Returns follow-ups associated with this group, restricted to items assigned to the current user and unassigned items in groups where that user has follow-up rights. Items assigned to other people are omitted even if the current user can view them individually. Requires permission to administer or perform follow-ups in this group. Follow-ups whose subject person is archived are excluded. State filters are combined with OR; omission includes all states. Results are ordered by completion date descending, effective due date ascending, then ID. Pagination returns only meta.count for this page, without a total or last-page value.
pub fn list_with(&self, group_id: impl Display, query: &GetGroupsGroupIdFollowupsQuery) -> Result<Vec<models::FollowUp2>> {
let path = format!("/groups/{}/followups", seg(group_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List follow-ups for group memberships
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, group_id: impl Display, query: &GetGroupsGroupIdFollowupsQuery) -> Items<models::FollowUp2> {
let path = format!("/groups/{}/followups", seg(group_id));
self.client.items(&path, query.to_query())
}
}
/// `client.groups().meetings()`
#[derive(Clone, Copy)]
pub struct GroupsMeetingsResource<'a> {
client: &'a Client,
}
impl<'a> GroupsMeetingsResource<'a> {
pub fn members(&self) -> GroupsMeetingsMembersResource<'a> {
GroupsMeetingsMembersResource { client: self.client }
}
/// Create a group meeting
///
/// `POST /groups/{groupId}/meetings`
///
/// Creates one meeting at startDate and initializes attendance for eligible active group members as unsure. Requires authentication, permission to view the group and permission to manage its meetings. Send a UTC timestamp. Only startDate is accepted as meeting timing; endDate does not set a duration. dateFrom is a legacy alias for startDate. A duplicate meeting for the same group and start time returns 400.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-groups-id-meetings");
/// let body = models::PostGroupsIdMeetingsBody {
/// start_date: "2026-09-20T08:00:00Z".parse()?,
/// ..Default::default()
/// };
/// let result = client.groups().meetings().create(42, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, group_id: impl Display, body: &models::PostGroupsIdMeetingsBody) -> Result<models::GroupMeeting> {
let path = format!("/groups/{}/meetings", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a group meeting
///
/// `DELETE /groups/{groupId}/meetings/{meetingId}`
///
/// Permanently deletes the meeting. This differs from setting isCanceled=true, which retains the record. Requires authentication, permission to view the group and permission to manage its meetings. Use a meetingId belonging to the group in the URL. There is no dry-run option. Returns 204 without a response body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().meetings().delete(42, 120)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_id: impl Display, meeting_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/meetings/{}", seg(group_id), seg(meeting_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a group meeting
///
/// `GET /groups/{groupId}/meetings/{meetingId}`
///
/// Returns one meeting with attendance statistics. Requires authentication, permission to view the group and permission to manage its meetings. Use a meetingId belonging to the group in the URL. No include parameters are supported; use the meeting list with include=attendances or the meeting members endpoint for individual attendance.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-meetings-meetingId");
/// let meeting = client.groups().meetings().get(42, 120)?;
/// println!("{}", meeting.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_id: impl Display, meeting_id: impl Display) -> Result<models::GroupMeeting> {
let path = format!("/groups/{}/meetings/{}", seg(group_id), seg(meeting_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Export group meeting attendance or overview
///
/// `GET /groups/{groupId}/meetings/export`
///
/// Exports meetings in the inclusive from / exclusive to date range. Requires authentication and permission to manage group meetings. Defaults to yesterday at midnight through midnight 30 days after today, in the application timezone.
///
/// meetings_members creates a person-by-meeting attendance matrix, subject to attendance visibility and group-history permissions. meetings_overview creates one row per meeting with status, attendance counts, guest count and comment. Headings and attendance labels are translated.
///
/// The result is a downloadable CSV (default) or XLSX file, not a JSON response. All matching meetings are exported; page and limit are not supported. The current date-range implementation orders meetings oldest first even when direction=backward is supplied.
///
/// Use [`Self::get_export_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.groups().meetings().get_export(42)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_export(&self, group_id: impl Display) -> Result<Vec<u8>> {
self.get_export_with(group_id, &Default::default())
}
/// Export group meeting attendance or overview
///
/// Like [`Self::get_export`], with query parameters.
///
/// `GET /groups/{groupId}/meetings/export`
///
/// Exports meetings in the inclusive from / exclusive to date range. Requires authentication and permission to manage group meetings. Defaults to yesterday at midnight through midnight 30 days after today, in the application timezone.
///
/// meetings_members creates a person-by-meeting attendance matrix, subject to attendance visibility and group-history permissions. meetings_overview creates one row per meeting with status, attendance counts, guest count and comment. Headings and attendance labels are translated.
///
/// The result is a downloadable CSV (default) or XLSX file, not a JSON response. All matching meetings are exported; page and limit are not supported. The current date-range implementation orders meetings oldest first even when direction=backward is supplied.
pub fn get_export_with(&self, group_id: impl Display, query: &GetGroupsGroupIdMeetingsExportQuery) -> Result<Vec<u8>> {
let path = format!("/groups/{}/meetings/export", seg(group_id));
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Get meetings for a group
///
/// `GET /groups/{groupId}/meetings`
///
/// Returns meetings and attendance statistics for a group. Requires authentication, permission to view the group and permission to manage its meetings.
///
/// Without direction, returns all meetings with startDate >= from and startDate < to, ordered oldest first. page and limit do not restrict this date-range mode. Defaults are yesterday at midnight through midnight 30 days after today, in the application timezone.
///
/// With direction=forward, returns meetings strictly after from, oldest first. With direction=backward, returns meetings strictly before from, newest first. In this mode to is ignored, and page/limit select a page. The response has no pagination object or total page count.
///
/// meta.count is the number returned; meta.statistics covers all meetings of the group. In date-range mode, meta.previous and meta.next contain a matching meeting timestamp before from or after to, or null. They are omitted in directional mode. Use include=attendances to add person-level attendance states.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-id-meetings");
/// for meeting in client.groups().meetings().list(42)? {
/// println!("{}", meeting.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display) -> Result<Vec<models::GroupMeeting>> {
self.list_with(group_id, &Default::default())
}
/// Get meetings for a group
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /groups/{groupId}/meetings`
///
/// Returns meetings and attendance statistics for a group. Requires authentication, permission to view the group and permission to manage its meetings.
///
/// Without direction, returns all meetings with startDate >= from and startDate < to, ordered oldest first. page and limit do not restrict this date-range mode. Defaults are yesterday at midnight through midnight 30 days after today, in the application timezone.
///
/// With direction=forward, returns meetings strictly after from, oldest first. With direction=backward, returns meetings strictly before from, newest first. In this mode to is ignored, and page/limit select a page. The response has no pagination object or total page count.
///
/// meta.count is the number returned; meta.statistics covers all meetings of the group. In date-range mode, meta.previous and meta.next contain a matching meeting timestamp before from or after to, or null. They are omitted in directional mode. Use include=attendances to add person-level attendance states.
pub fn list_with(&self, group_id: impl Display, query: &GetGroupsIdMeetingsQuery) -> Result<Vec<models::GroupMeeting>> {
let path = format!("/groups/{}/meetings", seg(group_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get meetings for a group
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, group_id: impl Display, query: &GetGroupsIdMeetingsQuery) -> Items<models::GroupMeeting> {
let path = format!("/groups/{}/meetings", seg(group_id));
self.client.items(&path, query.to_query())
}
/// Update a group meeting
///
/// `PUT /groups/{groupId}/meetings/{meetingId}`
///
/// Updates meeting timing, completion, cancellation and feedback. Requires authentication, permission to view the group and permission to manage its meetings. Use a meetingId belonging to the group in the URL.
///
/// Supply startDate, isCompleted and isCanceled; they have no implicit request defaults. Omitted numGuests, comment and pollResult are cleared to null. This is not a partial update. Blank comments are trimmed to null. endDate is not stored or updated. A duplicate start time for this group returns 400.
///
/// Setting isCompleted=true locks attendance changes. Send false to reopen the meeting. This operation does not change individual attendance states or hasEditingStarted. Returns the updated meeting in data.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-groups-groupId-meetings-meetingId");
/// let body = models::PutGroupsGroupIdMeetingsMeetingIdBody {
/// is_canceled: false,
/// is_completed: false,
/// start_date: "2026-09-20T08:00:00Z".parse()?,
/// ..Default::default()
/// };
/// let result = client.groups().meetings().update(42, 120, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, group_id: impl Display, meeting_id: impl Display, body: &models::PutGroupsGroupIdMeetingsMeetingIdBody) -> Result<models::GroupMeeting> {
let path = format!("/groups/{}/meetings/{}", seg(group_id), seg(meeting_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.groups().meetings().members()`
#[derive(Clone, Copy)]
pub struct GroupsMeetingsMembersResource<'a> {
client: &'a Client,
}
impl<'a> GroupsMeetingsMembersResource<'a> {
/// Revoke a meeting check-in
///
/// `DELETE /groups/{groupId}/meetings/{meetingId}/members/{memberId}`
///
/// Sets one person's attendance to absent (the default) or unsure. This writes an attendance state rather than deleting the person or membership, and sets hasEditingStarted=true. Requires authentication and permission to manage meetings for the group. Completed meetings reject this attendance change with 400; reopen the meeting before editing attendance.
///
/// The request body is optional. On success the response is 200 with a GroupMeeting directly at the JSON root, without a data wrapper. A meeting belonging to another group or an unknown person returns 404.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("delete-groups-groupId-meetings-meetingId-members-memberId");
/// let body = models::DeleteGroupsGroupIdMeetingsMeetingIdMembersMemberIdBody {
/// status: Some("absent".into()),
/// ..Default::default()
/// };
/// let member = client.groups().meetings().members().delete(42, 120, 17, &body)?;
/// println!("{}", member.id);
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_id: impl Display, meeting_id: impl Display, member_id: impl Display, body: &models::DeleteGroupsGroupIdMeetingsMeetingIdMembersMemberIdBody) -> Result<models::GroupMeeting> {
let path = format!("/groups/{}/meetings/{}/members/{}", seg(group_id), seg(meeting_id), seg(member_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Delete, &path, &query, Some(&body))
}
/// Get attendance for a group meeting
///
/// `GET /groups/{groupId}/meetings/{meetingId}/members`
///
/// Returns person-level attendance for the meeting. Requires authentication, permission to view the group and permission to manage its meetings.
///
/// The list combines recorded attendance with visible group members; membership details are included only for current visible active memberships. Former members may appear when group-history permissions allow it, with member=null. A person without an attendance record receives status=not-in-group. personId identifies the person; isCheckedIn is true only for present.
///
/// Returns an unpaginated data array with meta.count. It does not return meta.totalCheckedIn. A meeting belonging to another group returns 404.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-meetings-meetingId-members");
/// for member in client.groups().meetings().members().list(42, 120)? {
/// println!("{}", member.is_checked_in);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display, meeting_id: impl Display) -> Result<Vec<models::GroupMeetingMember>> {
let path = format!("/groups/{}/meetings/{}/members", seg(group_id), seg(meeting_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Set undecided meeting attendance
///
/// `POST /groups/{groupId}/meetings/{meetingId}/members/missing`
///
/// Changes only existing unsure attendance records to the supplied present or absent status. Other attendance records are unchanged, and no new person records are added. Sets hasEditingStarted=true. Requires authentication and permission to manage meetings for the group. Completed meetings reject this attendance change with 400; reopen the meeting before editing attendance. Returns 204 without a response body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostGroupsGroupIdMeetingsMeetingIdMembersMissingBody {
/// status: "absent".into(),
/// ..Default::default()
/// };
/// client.groups().meetings().members().missing(42, 120, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn missing(&self, group_id: impl Display, meeting_id: impl Display, body: &models::PostGroupsGroupIdMeetingsMeetingIdMembersMissingBody) -> Result<()> {
let path = format!("/groups/{}/meetings/{}/members/missing", seg(group_id), seg(meeting_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Reset meeting attendance
///
/// `POST /groups/{groupId}/meetings/{meetingId}/members/reset`
///
/// Resets all existing attendance records for the meeting to unsure, including records previously marked present or absent. Clears hasEditingStarted. This does not remove memberships or clear meeting feedback or guest counts. Requires authentication and permission to manage meetings for the group. Completed meetings reject this attendance change with 400; reopen the meeting before editing attendance. Returns 204 without a response body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().meetings().members().reset(42, 120)?;
/// # Ok(())
/// # }
/// ```
pub fn reset(&self, group_id: impl Display, meeting_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/meetings/{}/members/reset", seg(group_id), seg(meeting_id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
}
/// `client.groups().member_fields()`
#[derive(Clone, Copy)]
pub struct GroupsMemberFieldsResource<'a> {
client: &'a Client,
}
impl<'a> GroupsMemberFieldsResource<'a> {
pub fn group(&self) -> GroupsMemberFieldsGroupResource<'a> {
GroupsMemberFieldsGroupResource { client: self.client }
}
pub fn person(&self) -> GroupsMemberFieldsPersonResource<'a> {
GroupsMemberFieldsPersonResource { client: self.client }
}
/// List configured membership and person fields
///
/// `GET /groups/{groupId}/memberfields`
///
/// Returns all configured fields for this group, ordered together by sortKey. type=group describes a field whose values belong to individual memberships; type=person links an existing global person field into the group’s membership/signup UI. The list contains field definitions, not members or their entered values. Requires visibility of the group. Field definitions are not additionally filtered by their securityLevel or useInRegistrationForm flag. Results are not paginated; meta.count is the total number of returned definitions. Anonymous access is possible when the group is publicly visible.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-memberfields");
/// for member_field in client.groups().member_fields().list(42)? {
/// println!("{:?}", member_field);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display) -> Result<Vec<serde_json::Value>> {
let path = format!("/groups/{}/memberfields", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.groups().member_fields().group()`
#[derive(Clone, Copy)]
pub struct GroupsMemberFieldsGroupResource<'a> {
client: &'a Client,
}
impl<'a> GroupsMemberFieldsGroupResource<'a> {
/// Create a group-specific membership field
///
/// `POST /groups/{groupId}/memberfields/group`
///
/// Creates a field whose values are stored separately for each person’s membership in this group. Requires permission to edit group member fields. name must be unique within the group; referenceName must also be unique and is generated from name when omitted. Choose fieldTypeCode at creation; subsequent field updates cannot change it. Select-like options receive new backend IDs, and defaults are normalized to those IDs. The response is the field definition, without a type wrapper or member values. Existing memberships are not populated with the new default by this endpoint.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-groups-groupId-memberfields-group");
/// let body = models::GroupMemberFieldGroupCreate {
/// field_type_code: "text".into(),
/// name: "T-Shirt size".into(),
/// required_in_registration_form: false,
/// security_level: 1,
/// use_in_registration_form: true,
/// ..Default::default()
/// };
/// let result = client.groups().member_fields().group().create(42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, group_id: impl Display, body: &models::GroupMemberFieldGroupCreate) -> Result<models::GroupMemberFieldGroup> {
let path = format!("/groups/{}/memberfields/group", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a membership field and its stored values
///
/// `DELETE /groups/{groupId}/memberfields/group/{groupMemberFieldId}`
///
/// Deletes the group-specific field definition, its selection options and all stored member values for that field. Requires permission to edit member fields of the path group. Supply a field belonging to that group. This operation has no delete-preview workflow and returns 204 without a body. Global person fields and person-field values are unaffected.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().member_fields().group().delete(42, 42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_id: impl Display, group_member_field_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/memberfields/group/{}", seg(group_id), seg(group_member_field_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Partially update a membership field definition
///
/// `PATCH /groups/{groupId}/memberfields/group/{groupMemberFieldId}`
///
/// Updates only supplied fields of a field belonging to the path group. Requires permission to edit group member fields. Empty {} is accepted and preserves the definition. fieldTypeCode is ignored; a field’s type cannot be changed here. When updating choices, send the full list with numeric IDs for retained choices; omitted IDs are deleted and removed from all member selections and the default. Use options=\[\] to remove all choices; omit options to preserve it. Avoid options=null because the current implementation reallocates IDs and can clear existing selections. Unlike create and PUT, PATCH does not check uniqueness of the display name, but it checks changed reference names.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("patch-groups-groupId-memberfields-group-groupMemberFieldId");
/// let body = models::GroupMemberFieldGroupPatch {
/// name: Some("T-Shirt size".into()),
/// ..Default::default()
/// };
/// let result = client.groups().member_fields().group().patch(42, 42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, group_id: impl Display, group_member_field_id: impl Display, body: &models::GroupMemberFieldGroupPatch) -> Result<models::GroupMemberFieldGroup> {
let path = format!("/groups/{}/memberfields/group/{}", seg(group_id), seg(group_member_field_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
/// Replace a membership field definition
///
/// `PUT /groups/{groupId}/memberfields/group/{groupMemberFieldId}`
///
/// Updates a field belonging to the path group. Requires permission to edit group member fields and the required name/referenceName/securityLevel/registration flags. Unlike PATCH, omitted notes, signup labels and defaultValue are cleared, and sortKey resets to zero. The display name and reference name must be unique within the group. The field type is unchanged. Send the full option list with numeric IDs for retained choices: removed choices are removed from member selections and defaults. Omitting options or sending null currently reallocates existing choice IDs and can clear selections. The returned object is the saved field definition.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-groups-groupId-memberfields-group-groupMemberFieldId");
/// let body = models::GroupMemberFieldGroupUpdate {
/// name: "T-Shirt size".into(),
/// reference_name: "t-shirt-size".into(),
/// required_in_registration_form: false,
/// security_level: 1,
/// use_in_registration_form: true,
/// ..Default::default()
/// };
/// let result = client.groups().member_fields().group().update(42, 42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, group_id: impl Display, group_member_field_id: impl Display, body: &models::GroupMemberFieldGroupUpdate) -> Result<models::GroupMemberFieldGroup> {
let path = format!("/groups/{}/memberfields/group/{}", seg(group_id), seg(group_member_field_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.groups().member_fields().person()`
#[derive(Clone, Copy)]
pub struct GroupsMemberFieldsPersonResource<'a> {
client: &'a Client,
}
impl<'a> GroupsMemberFieldsPersonResource<'a> {
/// Remove a person field from a group’s member form
///
/// `DELETE /groups/{groupId}/memberfields/person/{fieldId}`
///
/// Removes the configuration linking this global person field to the group’s membership/signup UI. The underlying field definition and all values stored on persons are retained. Requires permission to edit group member fields. The lookup is scoped to both the group and dbField.id. Returns 204 on deletion and 404 when no such configuration exists; there is no delete-preview workflow.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().member_fields().person().delete(42, 200)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_id: impl Display, field_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/memberfields/person/{}", seg(group_id), seg(field_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Configure a person field for a group’s member form
///
/// `PUT /groups/{groupId}/memberfields/person/{fieldId}`
///
/// Creates or updates the link from an existing global person field to this group’s membership/signup UI. Requires permission to edit group member fields. The path uses dbField.id, not the configuration row ID. Both sortKey and requiredInRegistrationForm must be supplied. The request does not change the global field definition or existing person values. Returns 200 with the saved configuration, including the full underlying dbField, for both create and update.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::GroupMemberFieldPersonUpdate {
/// required_in_registration_form: false,
/// sort_key: 20,
/// ..Default::default()
/// };
/// let result = client.groups().member_fields().person().update(42, 200, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, group_id: impl Display, field_id: impl Display, body: &models::GroupMemberFieldPersonUpdate) -> Result<models::GroupMemberFieldPerson> {
let path = format!("/groups/{}/memberfields/person/{}", seg(group_id), seg(field_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.groups().members()`
#[derive(Clone, Copy)]
pub struct GroupsMembersResource<'a> {
client: &'a Client,
}
impl<'a> GroupsMembersResource<'a> {
pub fn documents(&self) -> GroupsMembersDocumentsResource<'a> {
GroupsMembersDocumentsResource { client: self.client }
}
pub fn followups(&self) -> GroupsMembersFollowupsResource<'a> {
GroupsMembersFollowupsResource { client: self.client }
}
pub fn routines(&self) -> GroupsMembersRoutinesResource<'a> {
GroupsMembersRoutinesResource { client: self.client }
}
/// Export visible group members with selected columns
///
/// `POST /groups/{groupId}/members/export`
///
/// Downloads the same membership scope as GET on this path, using an optional JSON config. Omitted/null/empty config uses the default columns; {template: allin} selects the full discovered catalog. For custom columns, send version 10 and ordered pinned/unpinned lists. person.id is always included, prepended when missing. Some person fields expand into multiple columns; pinned columns are frozen in XLSX. Unknown keys and malformed configurations are not reliably validated and may cause 500. Legacy version 9 is migrated internally but has known custom-column migration limitations; new clients should use version 10. The request is read-only and does not save the export configuration.
///
/// Use [`Self::create_export_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::GroupMemberExportCreate::default();
/// let data = client.groups().members().create_export(42, &body)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn create_export(&self, group_id: impl Display, body: &models::GroupMemberExportCreate) -> Result<Vec<u8>> {
self.create_export_with(group_id, &Default::default(), body)
}
/// Export visible group members with selected columns
///
/// Like [`Self::create_export`], with query parameters.
///
/// `POST /groups/{groupId}/members/export`
///
/// Downloads the same membership scope as GET on this path, using an optional JSON config. Omitted/null/empty config uses the default columns; {template: allin} selects the full discovered catalog. For custom columns, send version 10 and ordered pinned/unpinned lists. person.id is always included, prepended when missing. Some person fields expand into multiple columns; pinned columns are frozen in XLSX. Unknown keys and malformed configurations are not reliably validated and may cause 500. Legacy version 9 is migrated internally but has known custom-column migration limitations; new clients should use version 10. The request is read-only and does not save the export configuration.
pub fn create_export_with(&self, group_id: impl Display, query: &PostGroupsIdMembersExportQuery, body: &models::GroupMemberExportCreate) -> Result<Vec<u8>> {
let path = format!("/groups/{}/members/export", seg(group_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body))
}
/// Remove a person’s group membership
///
/// `DELETE /groups/{groupId}/members/{personId}`
///
/// Removes the membership linking groupId and personId. personId identifies the person, while data.id in membership responses identifies the membership record. The person record is retained. Viewing the group and its members is required, together with permission to delete members unless the current user is allowed to leave the group themselves. For an allowed self-service departure, autoAccept determines the outcome: true removes the membership immediately; false changes its status to to_delete (pending removal) and resets its role to the group type’s default role. After authorization, a missing or invisible membership is ignored and the endpoint still returns 204. A 204 response therefore does not guarantee that a membership was deleted.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().members().delete(42, 42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_id: impl Display, person_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/members/{}", seg(group_id), seg(person_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a person’s group membership
///
/// `GET /groups/{groupId}/members/{personId}`
///
/// Returns the visible membership linking groupId and personId. personId is the person’s ID, not the membership record ID returned in data.id. The role and status describe this membership; they do not describe the person’s memberships in other groups. Comments, the end date and additional member fields are subject to field permissions. Returns 404 when the membership does not exist or is not visible to the current user.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-members-personId");
/// let member = client.groups().members().get(42, 42)?;
/// println!("{}", member.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_id: impl Display, person_id: impl Display) -> Result<models::GroupMember> {
let path = format!("/groups/{}/members/{}", seg(group_id), seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Export visible group members with the default columns
///
/// `GET /groups/{groupId}/members/export`
///
/// Downloads visible memberships of this group as CSV or XLSX. Archived persons and members hidden by the current user’s access rules are excluded; all membership workflow statuses are eligible. Default columns include person ID and name, role, membership status, comment, registering person, membership dates, waiting-list position and accessible group-specific member fields. Missing member-field values are represented by their configured defaults. Headers and formatted values use the current language. There is no pagination or explicit sort parameter. CSV is UTF-8 with semicolon separators. Use POST on this path to select columns; query config is ignored. A scope with no visible members yields no member rows.
///
/// Use [`Self::get_export_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.groups().members().get_export(42)?;
/// std::fs::write("ergebnis.xlsx", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_export(&self, group_id: impl Display) -> Result<Vec<u8>> {
self.get_export_with(group_id, &Default::default())
}
/// Export visible group members with the default columns
///
/// Like [`Self::get_export`], with query parameters.
///
/// `GET /groups/{groupId}/members/export`
///
/// Downloads visible memberships of this group as CSV or XLSX. Archived persons and members hidden by the current user’s access rules are excluded; all membership workflow statuses are eligible. Default columns include person ID and name, role, membership status, comment, registering person, membership dates, waiting-list position and accessible group-specific member fields. Missing member-field values are represented by their configured defaults. Headers and formatted values use the current language. There is no pagination or explicit sort parameter. CSV is UTF-8 with semicolon separators. Use POST on this path to select columns; query config is ignored. A scope with no visible members yields no member rows.
pub fn get_export_with(&self, group_id: impl Display, query: &GetGroupsGroupIdMembersExportQuery) -> Result<Vec<u8>> {
let path = format!("/groups/{}/members/export", seg(group_id));
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// List group memberships
///
/// `GET /groups/{groupId}/members`
///
/// Returns one page of visible memberships in this group. Each entry links a person to the group and includes their role and membership status. Memberships in all visible statuses are included unless group_member_statuses filters them. Filters are combined. Additional filters can use a group member field’s reference name or display name (=fieldValue), or a person-field key (person_=fieldValue). meta.count counts entries on the current page, meta.pagination.total counts filtered memberships across all pages, and meta.all counts visible memberships before applying filters. Additional person fields and enrichments must be requested explicitly.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-id-members");
/// for member in client.groups().members().list(42)? {
/// println!("{}", member.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display) -> Result<Vec<models::GroupMember>> {
self.list_with(group_id, &Default::default())
}
/// List group memberships
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /groups/{groupId}/members`
///
/// Returns one page of visible memberships in this group. Each entry links a person to the group and includes their role and membership status. Memberships in all visible statuses are included unless group_member_statuses filters them. Filters are combined. Additional filters can use a group member field’s reference name or display name (=fieldValue), or a person-field key (person_=fieldValue). meta.count counts entries on the current page, meta.pagination.total counts filtered memberships across all pages, and meta.all counts visible memberships before applying filters. Additional person fields and enrichments must be requested explicitly.
pub fn list_with(&self, group_id: impl Display, query: &GetGroupsIdMembersQuery) -> Result<Vec<models::GroupMember>> {
let path = format!("/groups/{}/members", seg(group_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List group memberships
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, group_id: impl Display, query: &GetGroupsIdMembersQuery) -> Items<models::GroupMember> {
let path = format!("/groups/{}/members", seg(group_id));
self.client.items(&path, query.to_query())
}
/// List membership history with previous and current values
///
/// `GET /groups/{groupId}/members/history`
///
/// Returns legacy membership history for this group, newest entry ID first. Requires view group history or the internal +view history permission. member_id refers to the affected person and actor_id to the person who made the change. Change filters have precedence rather than being combined: new_role_id overrides new_status, which overrides new_fields/has_field_changed. The previous snapshot remains the actual linked predecessor even if it does not match the filters. To fetch older entries, pass the last returned id as offset_id; meta.count counts this batch, without a total or next cursor. Stored historical comments/field values are returned without individual person visibility or field security filtering.
///
/// Use [`Self::list_history_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-members-history");
/// for history in client.groups().members().list_history(42)? {
/// println!("{}", history.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_history(&self, group_id: impl Display) -> Result<Vec<models::GroupMemberHistoryEntry>> {
self.list_history_with(group_id, &Default::default())
}
/// List membership history with previous and current values
///
/// Like [`Self::list_history`], with query parameters.
///
/// `GET /groups/{groupId}/members/history`
///
/// Returns legacy membership history for this group, newest entry ID first. Requires view group history or the internal +view history permission. member_id refers to the affected person and actor_id to the person who made the change. Change filters have precedence rather than being combined: new_role_id overrides new_status, which overrides new_fields/has_field_changed. The previous snapshot remains the actual linked predecessor even if it does not match the filters. To fetch older entries, pass the last returned id as offset_id; meta.count counts this batch, without a total or next cursor. Stored historical comments/field values are returned without individual person visibility or field security filtering.
pub fn list_history_with(&self, group_id: impl Display, query: &GetGroupsGroupIdMembersHistoryQuery) -> Result<Vec<models::GroupMemberHistoryEntry>> {
let path = format!("/groups/{}/members/history", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get group meetings with attendance for one person
///
/// `GET /groups/{groupId}/members/{personId}/meetings`
///
/// Returns every meeting of the group, paired with the requested person’s attendance status. Requires permission to view the group and manage its meetings. Meetings without an attendance record are included with status null; canceled and completed meetings are also included. The endpoint does not verify that the person exists or is currently a group member. Results are not paginated and have no guaranteed order. Attendance statistics are not calculated.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-members-personId-meetings");
/// for meeting in client.groups().members().list_meetings(42, 42)? {
/// println!("{:?}", meeting.status);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_meetings(&self, group_id: impl Display, person_id: impl Display) -> Result<Vec<models::GroupMemberMeeting>> {
let path = format!("/groups/{}/members/{}/meetings", seg(group_id), seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get field statistics for selected group roles
///
/// `GET /groups/{groupId}/members/statistics`
///
/// Aggregates non-archived persons with a membership in this group and one of the requested group-type roles. Membership workflow status is not filtered. Requires permission to view the group and its members. Requested fields are included only if their security level is accessible; unknown or inaccessible fields are silently omitted. Person fields are selected by database field key, custom membership fields by numeric field ID. With no requested fields the result is empty. This is an unpaginated list; meta.count counts returned field statistics, not people. Person date fields return earliest/latest values including the corresponding person; requesting such a field when no non-null value exists currently reaches an unhandled empty-result path.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-members-statistics");
/// let query = GetGroupsGroupIdMembersStatisticsQuery {
/// group_type_role_ids: Some(vec![8, 9]),
/// ..Default::default()
/// };
/// for statistic in client.groups().members().list_statistics(42, &query)? {
/// println!("{}", statistic.field_type);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_statistics(&self, group_id: impl Display, query: &GetGroupsGroupIdMembersStatisticsQuery) -> Result<Vec<models::GroupMemberStatistic>> {
let path = format!("/groups/{}/members/statistics", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update an existing group membership
///
/// `PATCH /groups/{groupId}/members/{personId}`
///
/// Updates the membership linking this group and person; it does not create one. Use PUT to add a person. Requires permission to view group members, to edit changed membership properties and to edit submitted custom fields at their security levels. Omitted properties are preserved. The current backend incompletely checks changes supplied as null. Changes run transactionally, update history and recalculate the person’s growth path. Waiting-list processing is suppressed: set status and position explicitly when both must change. Date-only and UTC start timestamps are accepted, while the response formats the start as a date. An empty object is accepted but still runs update/history processing.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("patch-groups-groupId-members-personId");
/// let body = models::MembershipUpdate {
/// comment: Some(Some("Available on weekends.".into())),
/// ..Default::default()
/// };
/// let result = client.groups().members().patch(42, 42, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, group_id: impl Display, person_id: impl Display, body: &models::MembershipUpdate) -> Result<models::GroupMember> {
let path = format!("/groups/{}/members/{}", seg(group_id), seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
/// Add a person to a group
///
/// `PUT /groups/{groupId}/members/{personId}`
///
/// Creates a membership for the person identified in the path. Both creation and legacy updating return 200. Requires permission to view group members and add members; updating an existing membership additionally checks changed membership properties and custom-field security levels. Set only_add=true to reject existing memberships. Updating through PUT is deprecated in the backend; use PATCH for partial changes. The legacy update path clears omitted comments and end dates but preserves omitted status, role, start date and waiting-list position. Creation checks group capacity unless ignoreGroupFull is true; waiting-list capacity has a separate override. Changes update history, trigger membership events and recalculate the growth path. The response includes a legacy duplicate under data\["0"\] and a top-level deprecation mapping; use the regular data properties.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-groups-groupId-members-personId");
/// let body = models::MembershipCreate {
/// comment: Some(Some("Available on weekends.".into())),
/// ..Default::default()
/// };
/// let result = client.groups().members().update(42, 42, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, group_id: impl Display, person_id: impl Display, body: &models::MembershipCreate) -> Result<models::PutGroupsGroupIdMembersPersonIdData> {
let path = format!("/groups/{}/members/{}", seg(group_id), seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.groups().members().documents()`
#[derive(Clone, Copy)]
pub struct GroupsMembersDocumentsResource<'a> {
client: &'a Client,
}
impl<'a> GroupsMembersDocumentsResource<'a> {
/// `GET /groups/{groupId}/members/{memberId}/documents/{htmlTemplateId}`
///
/// Get a document for a group member
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().members().documents().get(42, 42, 2)?;
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_id: impl Display, member_id: impl Display, html_template_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/members/{}/documents/{}", seg(group_id), seg(member_id), seg(html_template_id));
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
}
/// `client.groups().members().followups()`
#[derive(Clone, Copy)]
pub struct GroupsMembersFollowupsResource<'a> {
client: &'a Client,
}
impl<'a> GroupsMembersFollowupsResource<'a> {
/// Create a follow-up for a group member
///
/// `POST /groups/{groupId}/members/{personId}/followups`
///
/// Creates a task concerning this person in the context of the group. The subject person is distinct from ownerId, which identifies who should handle the task. Requires visibility of the person and permission to administer follow-ups in this group; a configured success group additionally requires permission to add members there, or the corresponding group-type permission. Missing/null ownerId leaves this group-related task unassigned. Dates may be in the past, and no due date is required. A new task specification is created from title and display/success settings. The current backend allows creation without an existing membership, storing a null membershipId; create the membership first so it can be found through the membership list/statistics routes.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-groups-id-members-id-followups");
/// let body = models::FollowUpCreate {
/// title: "Call Peter".into(),
/// ..Default::default()
/// };
/// let result = client.groups().members().followups().create(42, 42, &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, group_id: impl Display, person_id: impl Display, body: &models::FollowUpCreate) -> Result<models::FollowUp2> {
let path = format!("/groups/{}/members/{}/followups", seg(group_id), seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Count follow-ups for one membership by due state
///
/// `GET /groups/{groupId}/members/{personId}/followups/statistics`
///
/// Counts tasks linked to the current membership record for this group/person pair, excluding person-only tasks and tasks linked to older memberships. Counts follow-ups in this group assigned to the current user, plus unassigned follow-ups where that user has group follow-up rights. Items assigned to other people and archived subject persons are excluded, matching the group list scope. Requires permission to administer or perform follow-ups in this group. The counters cover all matching records and ignore list pagination and filter parameters. Due states use the effective due date and the server’s current date; dismissed and completed follow-ups share countDone. An empty scope returns all five counters as zero. If the membership does not exist, the current backend dereferences null instead of returning zero counters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-id-members-id-followups-statistics");
/// let statistic = client.groups().members().followups().get_statistics(42, 42)?;
/// println!("{}", statistic.count_done);
/// # Ok(())
/// # }
/// ```
pub fn get_statistics(&self, group_id: impl Display, person_id: impl Display) -> Result<models::FollowUpStatistics> {
let path = format!("/groups/{}/members/{}/followups/statistics", seg(group_id), seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List follow-ups for one group membership
///
/// `GET /groups/{groupId}/members/{personId}/followups`
///
/// Resolves the current membership linking this group and person, then lists follow-ups linked to that membership record ID. Follow-ups for an older deleted membership or person-only follow-ups are not included. Requires permission to administer or perform follow-ups in this group. Follow-ups whose subject person is archived are excluded. State filters are combined with OR; omission includes all states. Results are ordered by completion date descending, effective due date ascending, then ID. Pagination returns only meta.count for this page, without a total or last-page value. Results are restricted to the current owner and unassigned follow-ups in permitted groups; items assigned to others are omitted. A missing membership currently causes an unhandled null access rather than an empty list.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-members-personId-followups");
/// for followup in client.groups().members().followups().list(42, 42)? {
/// println!("{}", followup.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display, person_id: impl Display) -> Result<Vec<models::FollowUp2>> {
self.list_with(group_id, person_id, &Default::default())
}
/// List follow-ups for one group membership
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /groups/{groupId}/members/{personId}/followups`
///
/// Resolves the current membership linking this group and person, then lists follow-ups linked to that membership record ID. Follow-ups for an older deleted membership or person-only follow-ups are not included. Requires permission to administer or perform follow-ups in this group. Follow-ups whose subject person is archived are excluded. State filters are combined with OR; omission includes all states. Results are ordered by completion date descending, effective due date ascending, then ID. Pagination returns only meta.count for this page, without a total or last-page value. Results are restricted to the current owner and unassigned follow-ups in permitted groups; items assigned to others are omitted. A missing membership currently causes an unhandled null access rather than an empty list.
pub fn list_with(&self, group_id: impl Display, person_id: impl Display, query: &GetGroupsGroupIdMembersPersonIdFollowupsQuery) -> Result<Vec<models::FollowUp2>> {
let path = format!("/groups/{}/members/{}/followups", seg(group_id), seg(person_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List follow-ups for one group membership
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, group_id: impl Display, person_id: impl Display, query: &GetGroupsGroupIdMembersPersonIdFollowupsQuery) -> Items<models::FollowUp2> {
let path = format!("/groups/{}/members/{}/followups", seg(group_id), seg(person_id));
self.client.items(&path, query.to_query())
}
}
/// `client.groups().members().routines()`
#[derive(Clone, Copy)]
pub struct GroupsMembersRoutinesResource<'a> {
client: &'a Client,
}
impl<'a> GroupsMembersRoutinesResource<'a> {
/// Delete a membership routine and its binding
///
/// `DELETE /groups/{groupId}/members/routines/{roleId}/{groupMemberStatus}`
///
/// Deletes the binding for this exact group, group-type role and membership status, and also deletes the entire referenced routine and its steps. This is not an unlink-only operation. There is no delete-preview workflow. Requires authentication; this controller/service currently omit the group-specific permission checks used by the regular routine API. Missing bindings currently cause a server error rather than an idempotent 204 or a defined 404.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().members().routines().delete(42, 12, "active")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_id: impl Display, role_id: impl Display, group_member_status: impl Display) -> Result<()> {
let path = format!("/groups/{}/members/routines/{}/{}", seg(group_id), seg(role_id), seg(group_member_status));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// List routine bindings for membership roles and statuses
///
/// `GET /groups/{groupId}/members/routines`
///
/// Lists the routines bound to role/status combinations in this group, including disabled routines and their nested steps. A binding selects which automation applies to matching memberships; it is separate from the execution progress of any individual member. The list is not paginated and has no guaranteed ordering. Requires authentication; the current controller/service do not perform an additional group-specific permission check. A group with no bindings returns an empty list. Action data is converted from its stored form by the registered action handler before being returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-members-routines");
/// for routine in client.groups().members().routines().list(42)? {
/// println!("{}", routine.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display) -> Result<Vec<models::GroupMembershipRoutine>> {
let path = format!("/groups/{}/members/routines", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Create a membership routine binding if absent
///
/// `PUT /groups/{groupId}/members/routines/{roleId}/{groupMemberStatus}`
///
/// Binds an existing empty routine to this exact group, group-type role and membership status. Create the routine first and provide its ID; a routine with existing steps is rejected with 422. The response includes the binding and nested routine. If the binding already exists, this request returns it unchanged and ignores the submitted routineId. Requires authentication; the current controller/service omit group-specific permission checks. This endpoint does not start executions or change routine steps. Missing/nonexistent routine IDs for a new binding currently cause a server error.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::GroupMembershipRoutineUpdate {
/// routine_id: Some(5),
/// ..Default::default()
/// };
/// let result = client.groups().members().routines().update(42, 12, "active", &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, group_id: impl Display, role_id: impl Display, group_member_status: impl Display, body: &models::GroupMembershipRoutineUpdate) -> Result<models::GroupMembershipRoutine> {
let path = format!("/groups/{}/members/routines/{}/{}", seg(group_id), seg(role_id), seg(group_member_status));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.groups().news_letter_integrations()`
#[derive(Clone, Copy)]
pub struct GroupsNewsLetterIntegrationsResource<'a> {
client: &'a Client,
}
impl<'a> GroupsNewsLetterIntegrationsResource<'a> {
/// Connect a group to an external newsletter list
///
/// `POST /groups/{groupId}/newsletter-integrations`
///
/// Creates a stored mapping and immediately starts synchronizing eligible active, non-archived members with email addresses. This request can create an external list, subscribe contacts and send confirmation emails. Requires visibility of the group and members plus the global churchgroup permission administer groups. Select an active provider and use exactly one of listId or createListName. A provider/list pair can belong to only one group. existingMembersHandling controls initial consent handling; optInRequired is retained for later sync. A successful response confirms the mapping was created, but individual contact synchronization can fail and is tracked separately. External provider operations cannot be undone by a local database rollback.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::NewsletterIntegrationGroupMappingCreate {
/// opt_in_required: true,
/// provider: "Mailjet".into(),
/// ..Default::default()
/// };
/// let result = client.groups().news_letter_integrations().create(42, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, group_id: impl Display, body: &models::NewsletterIntegrationGroupMappingCreate) -> Result<models::NewsletterIntegrationGroupMapping> {
let path = format!("/groups/{}/newsletter-integrations", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Remove a newsletter mapping and unsubscribe its contacts
///
/// `DELETE /groups/{groupId}/newsletter-integrations/{provider}/{listId}`
///
/// Removes this group/provider/list mapping and its local newsletter-person records, then unsubscribes their stored email addresses from the external list if the provider is active. The external list itself is retained. Requires visibility of the group and members plus the global churchgroup permission administer groups. A missing mapping is ignored and returns 204. Local deletion is committed before the provider call: a provider error may leave external subscriptions active after the local mapping is gone. When the provider is inactive or unknown, only local records are removed.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().news_letter_integrations().delete(42, "Mailjet", "12345")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_id: impl Display, provider: impl Display, list_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/newsletter-integrations/{}/{}", seg(group_id), seg(provider), seg(list_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// List a group’s newsletter list mappings
///
/// `GET /groups/{groupId}/newsletter-integrations`
///
/// Returns stored links to external newsletter lists, including disabled/unavailable providers. Requires visibility of the group and members plus the global churchgroup permission administer groups. This request does not contact newsletter providers or refresh list names/status. The unpaginated list has no defined order; meta.count is the number of mappings. An accessible group without mappings returns an empty list.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-newsletter-integrations");
/// for news_letter_integration in client.groups().news_letter_integrations().list(42)? {
/// println!("{}", news_letter_integration.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display) -> Result<Vec<models::NewsletterIntegrationGroupMapping>> {
let path = format!("/groups/{}/newsletter-integrations", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Resend pending newsletter confirmation emails
///
/// `POST /groups/{groupId}/newsletter-integrations/{provider}/{listId}/resend-optins`
///
/// Sends ChurchTools confirmation emails again for eligible pending newsletter-person records in this mapping. Requires visibility of the group and members plus the global churchgroup permission "administer groups". Selecting one recipient with `person_id` additionally requires visibility of that person. Candidates must have an active membership, a non-archived person, no successful synchronization, no unsubscribe date and no confirmed double opt-in. Previously sent requests are included; each recipient gets a new token, invalidating the old link. Email addresses already synchronized for the same list are excluded and candidates are grouped by stored email. Without `person_id`, missing mappings and empty candidate sets return `204`. With `person_id`, no eligible candidate returns `404`. No count is returned. The current handler does not check `optInRequired`, provider activation or whether the provider handles double opt-in itself.
///
/// Use [`Self::resend_optins_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// client.groups().news_letter_integrations().resend_optins(42, "Mailjet", "12345", &body)?;
/// # Ok(())
/// # }
/// ```
pub fn resend_optins(&self, group_id: impl Display, provider: impl Display, list_id: impl Display, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<()> {
self.resend_optins_with(group_id, provider, list_id, &Default::default(), body)
}
/// Resend pending newsletter confirmation emails
///
/// Like [`Self::resend_optins`], with query parameters.
///
/// `POST /groups/{groupId}/newsletter-integrations/{provider}/{listId}/resend-optins`
///
/// Sends ChurchTools confirmation emails again for eligible pending newsletter-person records in this mapping. Requires visibility of the group and members plus the global churchgroup permission "administer groups". Selecting one recipient with `person_id` additionally requires visibility of that person. Candidates must have an active membership, a non-archived person, no successful synchronization, no unsubscribe date and no confirmed double opt-in. Previously sent requests are included; each recipient gets a new token, invalidating the old link. Email addresses already synchronized for the same list are excluded and candidates are grouped by stored email. Without `person_id`, missing mappings and empty candidate sets return `204`. With `person_id`, no eligible candidate returns `404`. No count is returned. The current handler does not check `optInRequired`, provider activation or whether the provider handles double opt-in itself.
pub fn resend_optins_with(&self, group_id: impl Display, provider: impl Display, list_id: impl Display, query: &PostGroupsGroupIdNewsletterIntegrationsProviderListIdResendOptinsQuery, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<()> {
let path = format!("/groups/{}/newsletter-integrations/{}/{}/resend-optins", seg(group_id), seg(provider), seg(list_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.groups().parents()`
#[derive(Clone, Copy)]
pub struct GroupsParentsResource<'a> {
client: &'a Client,
}
impl<'a> GroupsParentsResource<'a> {
/// Remove a direct parent-group relationship
///
/// `DELETE /groups/{groupId}/parents/{parentGroupId}`
///
/// Removes only the direct hierarchy edge from parentGroupId to groupId; both groups and their memberships remain. Other paths through the hierarchy are unaffected, so the parent may still be an indirect ancestor. Requires global group administration or hierarchy/group editing permission for both endpoints. A missing relationship is ignored and returns 204. Successful processing invalidates the authorization cache because hierarchy changes can affect inherited permissions.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.groups().parents().delete(42, 12)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, group_id: impl Display, parent_group_id: impl Display) -> Result<()> {
let path = format!("/groups/{}/parents/{}", seg(group_id), seg(parent_group_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get child groups
///
/// `GET /groups/{groupId}/parents`
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-groupId-parents");
/// for parent in client.groups().parents().list("abc123")? {
/// println!("{}", parent.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display) -> Result<Vec<models::DomainObjectGroup>> {
self.list_with(group_id, &Default::default())
}
/// Get child groups
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /groups/{groupId}/parents`
pub fn list_with(&self, group_id: impl Display, query: &GetGroupsGroupIdParentsQuery) -> Result<Vec<models::DomainObjectGroup>> {
let path = format!("/groups/{}/parents", seg(group_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get child groups
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, group_id: impl Display, query: &GetGroupsGroupIdParentsQuery) -> Items<models::DomainObjectGroup> {
let path = format!("/groups/{}/parents", seg(group_id));
self.client.items(&path, query.to_query())
}
/// Add a direct parent-group relationship
///
/// `PUT /groups/{groupId}/parents/{parentGroupId}`
///
/// Adds parentGroupId as a direct parent of groupId. Groups can have multiple parents; this adds an edge rather than replacing existing parents, and does not copy memberships. Requires global group administration or hierarchy/group editing permission for both groups. Self-parenting and a relationship that would create a cycle are rejected with 400. An existing direct relationship also returns 400, so repeating a successful PUT is not an idempotent success. Success returns 201 without a JSON body and invalidates the authorization cache because the hierarchy can affect inherited permissions.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// client.groups().parents().update(42, 12, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, group_id: impl Display, parent_group_id: impl Display, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<()> {
let path = format!("/groups/{}/parents/{}", seg(group_id), seg(parent_group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.groups().qrcode_checkin()`
#[derive(Clone, Copy)]
pub struct GroupsQrcodeCheckinResource<'a> {
client: &'a Client,
}
impl<'a> GroupsQrcodeCheckinResource<'a> {
/// Get an existing check-in ticket for a person
///
/// `GET /groups/{groupId}/qrcodecheckin/{personId}`
///
/// Returns the stored ticket for this person and group, without generating one or recording attendance. The current user may retrieve their own ticket. Retrieving another person’s ticket requires group/group-type membership editing permission or internal edit basic group memberships. Returns 404 when no matching ticket exists. The lookup does not recheck current ticket eligibility, expiry, use or QR-check-in activation; inspect the lifecycle fields separately. No meta envelope is returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-id-qrcodecheckin-personId");
/// let qrcode_checkin = client.groups().qrcode_checkin().get(42, 42)?;
/// println!("{}", qrcode_checkin.domain_id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_id: impl Display, person_id: impl Display) -> Result<models::GroupQRCodeCheckin> {
let path = format!("/groups/{}/qrcodecheckin/{}", seg(group_id), seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Generate a PDF download link for an existing check-in ticket
///
/// `GET /groups/{groupId}/qrcodecheckin/{personId}/pdf`
///
/// Generates a PDF containing the stored ticket’s QR code and returns its absolute download URL as JSON; this endpoint does not stream PDF bytes. The current user may request their own ticket, while another person’s ticket requires group/group-type membership editing permission or internal edit basic group memberships. A matching ticket must already exist; otherwise 404 is returned. Generating the link updates downloadedDate immediately, before any download occurs. This GET therefore writes state and creates a file. The lookup does not recheck QR-check-in activation, current role/membership eligibility or ticket lifecycle validity.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-id-qrcodecheckin-personId-pdf");
/// let pdf = client.groups().qrcode_checkin().get_pdf(42, 42)?;
/// println!("{}", pdf.url);
/// # Ok(())
/// # }
/// ```
pub fn get_pdf(&self, group_id: impl Display, person_id: impl Display) -> Result<models::GetGroupsIdQrcodecheckinPersonIdPdfData> {
let path = format!("/groups/{}/qrcodecheckin/{}/pdf", seg(group_id), seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List accessible check-in tickets for a group
///
/// `GET /groups/{groupId}/qrcodecheckin`
///
/// Returns existing stored tickets; it does not generate missing tickets or record attendance. Users with one of the group/group-type membership editing permissions or internal edit basic group memberships can retrieve all group tickets. Other authenticated users receive only their own ticket, wrapped in an array, or data=null when they have none. The privileged empty result is \[\] instead. Results are unpaginated and have no defined order or meta envelope. This lookup does not filter ticket expiry/use or recheck current QR-check-in enablement, role eligibility or active membership.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-id-qrcodecheckin");
/// let result = client.groups().qrcode_checkin().list(42)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display) -> Result<Option<Vec<models::GroupQRCodeCheckin>>> {
let path = format!("/groups/{}/qrcodecheckin", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Queue an existing check-in ticket for email
///
/// `POST /groups/{groupId}/qrcodecheckin/{personId}/send`
///
/// Queues a PDF ticket email and returns the current ticket, normally with isQueued=true while processing is pending. The current user may request their own ticket; sending another person’s ticket requires group/group-type membership editing permission or internal edit basic group memberships. A ticket must already exist. The subject person is preferred as recipient when they have an email and are not archived; otherwise the service attempts the membership’s registeredBy person. Already queued tickets are unchanged. With no eligible recipient this request still returns 200 without queuing. A previously sent ticket can be queued again. The worker generates the attachment and later updates sentDate/isQueued; this response does not confirm delivery. No request body selects recipients or content.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// let qrcode_checkin = client.groups().qrcode_checkin().send(42, 42, &body)?;
/// println!("{}", qrcode_checkin.domain_id);
/// # Ok(())
/// # }
/// ```
pub fn send(&self, group_id: impl Display, person_id: impl Display, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<models::GroupQRCodeCheckin> {
let path = format!("/groups/{}/qrcodecheckin/{}/send", seg(group_id), seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.groups().roles()`
#[derive(Clone, Copy)]
pub struct GroupsRolesResource<'a> {
client: &'a Client,
}
impl<'a> GroupsRolesResource<'a> {
/// Get all roles for this group
///
/// `GET /groups/{groupId}/roles`
///
/// Returns the roles configured for one group, including inactive roles. Each entry combines a shared role definition from the group's type with settings specific to this group, such as chat access, check-in QR codes and participant capacity.
/// id is the group-specific role settings ID used by PATCH /groups/{groupId}/roles/{roleId}. groupTypeRoleId links to the shared definition from GET /group/roles; do not interchange these IDs. isActive describes whether the role is enabled in this group, not the membership status of any person.
/// Requires authentication and permission to view the group. Accepts its numeric ID or chat GUID. Results are not paginated and are sorted by the shared role's type and sortKey ascending. meta.count includes all returned roles.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-id-roles");
/// for role in client.groups().roles().list(serde_json::json!(42))? {
/// println!("{}", role.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, group_id: impl Display) -> Result<Vec<models::GroupRole>> {
let path = format!("/groups/{}/roles", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update role settings for a group
///
/// `PATCH /groups/{groupId}/roles/{roleId}`
///
/// Updates settings for one role in one group. Use the entry's id from GET /groups/{groupId}/roles as roleId, not its groupTypeRoleId. This does not rename or reclassify the shared role definition.
/// Send only the settings to change. Omitted fields are preserved. growPathId=null clears the growth-path association; htmlTemplateIds=\[\] clears the template list. A supplied template list replaces the previous list. The default role cannot be deactivated. Returns the complete updated GroupRole in data, without meta.
/// Requires authentication and permission to view the group. Chat settings require one of administer groups, edit group, edit groups of grouptype or +admin group chat for this group. The other role settings except htmlTemplateIds require one of administer groups, edit group or edit groups of grouptype. Adding document templates requires one of administer groups, edit group, edit groups of grouptype or +edit group basic settings, plus the churchcore permission use church html templates for each added template. Templates must belong to the group-membership document domain.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::GroupRoleUpdate {
/// can_read_chat: Some(true),
/// ..Default::default()
/// };
/// let result = client.groups().roles().patch(42, 1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, group_id: impl Display, role_id: impl Display, body: &models::GroupRoleUpdate) -> Result<models::GroupRole> {
let path = format!("/groups/{}/roles/{}", seg(group_id), seg(role_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
}
/// `client.groups().wiki()`
#[derive(Clone, Copy)]
pub struct GroupsWikiResource<'a> {
client: &'a Client,
}
impl<'a> GroupsWikiResource<'a> {
pub fn categories(&self) -> GroupsWikiCategoriesResource<'a> {
GroupsWikiCategoriesResource { client: self.client }
}
}
/// `client.groups().wiki().categories()`
#[derive(Clone, Copy)]
pub struct GroupsWikiCategoriesResource<'a> {
client: &'a Client,
}
impl<'a> GroupsWikiCategoriesResource<'a> {
/// List wiki categories and recent pages from the current group role
///
/// `GET /groups/{groupId}/wiki/categories/pages`
///
/// Requires group visibility and a current active, non-archived membership. Categories are selected from view-category rights attached directly to this membership’s group role and then checked against the current user’s effective wiki permissions. Global wiki access alone does not add categories to this group-specific list; without a matching role/category grant the result is empty. Categories are ordered by sortKey then ID. Each category contains up to limit latest-version pages, sorted by modification date descending then title; total counts eligible pages before that limit. System pages are filtered by the wiki repository rules. Redirect pages are not removed. Page text and previews are omitted. meta.count counts returned categories, not pages; there is no page-number parameter.
///
/// Use [`Self::list_pages_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-groups-id-wiki-categories-pages");
/// for page in client.groups().wiki().categories().list_pages(42)? {
/// println!("{}", page.total);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_pages(&self, group_id: impl Display) -> Result<Vec<models::GroupWikiCategoryPagesItem>> {
self.list_pages_with(group_id, &Default::default())
}
/// List wiki categories and recent pages from the current group role
///
/// Like [`Self::list_pages`], with query parameters.
///
/// `GET /groups/{groupId}/wiki/categories/pages`
///
/// Requires group visibility and a current active, non-archived membership. Categories are selected from view-category rights attached directly to this membership’s group role and then checked against the current user’s effective wiki permissions. Global wiki access alone does not add categories to this group-specific list; without a matching role/category grant the result is empty. Categories are ordered by sortKey then ID. Each category contains up to limit latest-version pages, sorted by modification date descending then title; total counts eligible pages before that limit. System pages are filtered by the wiki repository rules. Redirect pages are not removed. Page text and previews are omitted. meta.count counts returned categories, not pages; there is no page-number parameter.
pub fn list_pages_with(&self, group_id: impl Display, query: &GetGroupsIdWikiCategoriesPagesQuery) -> Result<Vec<models::GroupWikiCategoryPagesItem>> {
let path = format!("/groups/{}/wiki/categories/pages", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.history()`
#[derive(Clone, Copy)]
pub struct HistoryResource<'a> {
client: &'a Client,
}
impl<'a> HistoryResource<'a> {
/// Get History
///
/// `GET /history`
///
/// Get history entries with links to domain objects.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-history");
/// let query = GetHistoryQuery {
/// domain_types: Some(vec!["beispiel".into()]),
/// domain_identifiers: Some(vec!["beispiel".into()]),
/// ..Default::default()
/// };
/// for history in client.history().list(&query)? {
/// println!("{}", history.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetHistoryQuery) -> Result<Vec<models::HistoryEntry>> {
let path = "/history".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get History
///
/// Like [`Self::list`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetHistoryQuery) -> Items<models::HistoryEntry> {
let path = "/history".to_owned();
self.client.items(&path, query.to_query())
}
}
/// `client.html_templates()`
#[derive(Clone, Copy)]
pub struct HtmlTemplatesResource<'a> {
client: &'a Client,
}
impl<'a> HtmlTemplatesResource<'a> {
/// Create a private or shared HTML template
///
/// `POST /htmltemplates`
///
/// Creates metadata and optional independent HTML/MJML files. The current user becomes owner even for a global template. email and bulkletter allow private templates (isGlobal defaults to false); groupmember-document and both donation-receipt types require isGlobal=true. Global creation requires the matching template domain’s administration permission. Neither source is required, so an empty template can be created. Source text is stored without rendering placeholders or compiling MJML. copyAssetsFromId copies only image files after template creation has committed; a copy failure can leave the new template and some assets in place. The current copy path does not check visibility of the source template.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-htmltemplates");
/// let body = models::HtmlTemplateCreate {
/// domain_type: "email".into(),
/// name: "Welcome email".into(),
/// ..Default::default()
/// };
/// let result = client.html_templates().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::HtmlTemplateCreate) -> Result<models::HtmlTemplate> {
let path = "/htmltemplates".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Check dependencies or delete an HTML template
///
/// `DELETE /htmltemplates/{templateId}`
///
/// Requires permission to edit the template (ownership or the domain’s global-template editing permission). Send dryRun explicitly. dryRun=true always returns 409 with a dependency report, even when deletion is allowed; it never returns a successful 204 preview. dryRun=false deletes an unblocked template, its HTML/MJML content files and image assets, then returns 204 without a body. References from group membership emails, bulk letters and group-role document configuration can block deletion, along with registered database dependency checks. An already missing template returns 404. Deleting a global template also invalidates cached authorization data.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = DeleteHtmltemplatesTemplateIdQuery {
/// dry_run: Some(true),
/// ..Default::default()
/// };
/// client.html_templates().delete(2, &query)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, template_id: impl Display, query: &DeleteHtmltemplatesTemplateIdQuery) -> Result<()> {
let path = format!("/htmltemplates/{}", seg(template_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get HTML template metadata
///
/// `GET /htmltemplates/{templateId}`
///
/// Returns metadata and content-file IDs for one visible template. Owners may view their own private or global templates; other users need the matching domain’s permission to view a global template. This endpoint does not return HTML/MJML source or asset contents. Use the html/mjml content routes or export for those. A template may exist with both content-file IDs null. Missing templates return 404; an existing inaccessible template returns 403.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-htmltemplates-templateId");
/// let html_template = client.html_templates().get(2)?;
/// println!("{}", html_template.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, template_id: impl Display) -> Result<models::HtmlTemplate> {
let path = format!("/htmltemplates/{}", seg(template_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Create a downloadable template export
///
/// `GET /htmltemplates/{templateId}/export`
///
/// Requires the same template visibility as GET /htmltemplates/{templateId}. Generates and stores a JSON export file, then returns its relative download URL in data; the export is not embedded in this response. The file contains name, domainType, html, mjml and assets. Each asset contains its name, fileHash and base64-encoded content. Ownership, global/private state and template metadata are not exported. The export file is scheduled for deletion after 30 days. This GET creates a new stored file on each call; missing content files or asset failures can prevent export.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-htmltemplates-templateId-export");
/// let result = client.html_templates().get_export(2)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_export(&self, template_id: impl Display) -> Result<String> {
let path = format!("/htmltemplates/{}/export", seg(template_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Read stored HTML template source
///
/// `GET /htmltemplates/{templateId}/html`
///
/// Returns the HTML source as a string inside the JSON data property. Requires template ownership or permission to view the global template. No placeholders are rendered, HTML is not sanitized by this read endpoint, and stored MJML is not compiled as a fallback. data=null means no HTML file is attached; an attached but missing file instead results in 404. The response is application/json rather than text/html.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-htmltemplates-templateId-html");
/// let result = client.html_templates().get_html(2)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_html(&self, template_id: impl Display) -> Result<Option<String>> {
let path = format!("/htmltemplates/{}/html", seg(template_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Read stored MJML template source
///
/// `GET /htmltemplates/{templateId}/mjml`
///
/// Returns the MJML editor source as a string inside the JSON data property. Requires template ownership or permission to view the global template. The source is returned unchanged, without compilation, placeholder rendering or validation; no MJML is inferred from an HTML file. data=null means no MJML file is attached. A referenced but missing content file results in 404. The response has no meta envelope.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-htmltemplates-templateId-mjml");
/// let result = client.html_templates().get_mjml(2)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_mjml(&self, template_id: impl Display) -> Result<Option<String>> {
let path = format!("/htmltemplates/{}/mjml", seg(template_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List visible templates for one purpose
///
/// `GET /htmltemplates`
///
/// Lists templates of exactly one required domain type, ordered by name. By default it includes the current user’s own templates and global templates allowed by the corresponding domain policy. Global does not mean public. onlyOwn=true filters by ownership, so it can include global templates owned by the current user. Other users’ private templates are omitted. The response contains metadata and file IDs, not source text or assets. Results are unpaginated; meta.count counts returned templates. domain_type is required unless its deprecated alias type is supplied; there is no default domain.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-htmltemplates");
/// let query = GetHtmltemplatesQuery {
/// domain_type: Some("email".into()),
/// ..Default::default()
/// };
/// for html_template in client.html_templates().list(&query)? {
/// println!("{}", html_template.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetHtmltemplatesQuery) -> Result<Vec<models::HtmlTemplate>> {
let path = "/htmltemplates".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update template metadata or replace source content
///
/// `PATCH /htmltemplates/{templateId}`
///
/// Requires template editing permission. If the resulting template is global, the domain’s global-template administration permission is additionally required, even when isGlobal is omitted. The template owner is retained when changing visibility. Private templates are allowed only for email/bulkletter; an email template referenced by group membership emails cannot become private. Omitted/null values preserve fields; content cannot be cleared by sending null. HTML and MJML replacements run first. A truthy htmlFileId is processed last, must belong to this template or be the current user’s unbound html_template upload, and replaces the HTML reference while deleting other content files and clearing MJML. Supply either content or htmlFileId to avoid unintentionally replacing just-written files. domainType and owner are not changed by this route.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("patch-htmltemplates-templateId");
/// let body = models::HtmlTemplateUpdate {
/// name: Some(Some("Updated welcome email".into())),
/// ..Default::default()
/// };
/// let result = client.html_templates().patch(2, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, template_id: impl Display, body: &models::HtmlTemplateUpdate) -> Result<models::HtmlTemplate> {
let path = format!("/htmltemplates/{}", seg(template_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
/// Upload image assets to a template
///
/// `POST /htmltemplates/{templateId}/uploadassets`
///
/// Requires permission to edit the template. Send one or more multipart file parts named files\[\]. The controller accepts client media types beginning with image/; it does not limit uploads to PNG. Files are saved as separate template image assets and returned in input order as editor descriptors. HTML and MJML source are not modified automatically. All client media-type headers are checked before storage, but files are then saved individually; a later storage failure can leave earlier assets persisted. This response has no meta envelope.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let file = Upload::from_path("logo.png")?;
/// for html_template in client.html_templates().upload_assets(2, &[file])? {
/// println!("{}", html_template.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn upload_assets(&self, template_id: impl Display, files: &[Upload]) -> Result<Vec<models::HtmlTemplateAssetUpload>> {
let path = format!("/htmltemplates/{}/uploadassets", seg(template_id));
let query: Query = Query::new();
let form: Query = Query::new();
let bytes = self.client.request_multipart(Method::Post, &path, &query, &form, "files[]", files)?;
crate::decode_data(&bytes)
}
}
/// `client.images()`
#[derive(Clone, Copy)]
pub struct ImagesResource<'a> {
client: &'a Client,
}
impl<'a> ImagesResource<'a> {
/// Get a public image
///
/// `GET /images/{fileId}/{hash}`
///
/// Returns image bytes for a public image URL and applies Glide transformations. The hash grants access without a login. SVG content is returned without transformation as an attachment.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.images().get(42, "abc123")?;
/// std::fs::write("ergebnis.bin", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get(&self, file_id: impl Display, hash: impl Display) -> Result<Vec<u8>> {
self.get_with(file_id, hash, &Default::default())
}
/// Get a public image
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /images/{fileId}/{hash}`
///
/// Returns image bytes for a public image URL and applies Glide transformations. The hash grants access without a login. SVG content is returned without transformation as an attachment.
pub fn get_with(&self, file_id: impl Display, hash: impl Display, query: &GetImagesFileIdHashQuery) -> Result<Vec<u8>> {
let path = format!("/images/{}/{}", seg(file_id), seg(hash));
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None)
}
/// Get a public image with path-encoded parameters
///
/// `GET /images/{fileId}/{hash}/{queryParams}`
///
/// Returns a public image with Glide transformations encoded in the final path segment. Image handling is otherwise identical to `GET /images/{fileId}/{hash}`.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.images().get_with_params(42, "abc123", "fm%3Dwebp%26q%3D80%26w%3D700%26h%3Dauto")?;
/// std::fs::write("ergebnis.bin", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_with_params(&self, file_id: impl Display, hash: impl Display, query_params: impl Display) -> Result<Vec<u8>> {
let path = format!("/images/{}/{}/{}", seg(file_id), seg(hash), seg(query_params));
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None)
}
/// Update image metadata
///
/// `PATCH /images/{id}`
///
/// Updates image description, attribution, AI flag and crop/focus options. Requires update permission for the owning object. Changing image options clears generated image caches.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ImageUpdate {
/// description: Some(Some("Congregation gathered outside the church.".into())),
/// ..Default::default()
/// };
/// let result = client.images().patch(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, id: impl Display, body: &models::ImageUpdate) -> Result<models::ImageMetadataUpdateResult> {
let path = format!("/images/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
/// Update image options and metadata
///
/// `PUT /images/{id}/options`
///
/// Updates image metadata through the same handler as `PATCH /images/{id}`. Requires update permission for the owning object.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ImageUpdate {
/// description: Some(Some("Congregation gathered outside the church.".into())),
/// ..Default::default()
/// };
/// let result = client.images().update_options(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update_options(&self, id: impl Display, body: &models::ImageUpdate) -> Result<models::ImageMetadataUpdateResult> {
let path = format!("/images/{}/options", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.info()`
#[derive(Clone, Copy)]
pub struct InfoResource<'a> {
client: &'a Client,
}
impl<'a> InfoResource<'a> {
/// Information about API
///
/// `GET /info`
///
/// The API envoles and dependes on the ChurchTools version. This endpoint provides the build version and CT version.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-info");
/// let info = client.info().get()?;
/// println!("{:?}", info.build);
/// # Ok(())
/// # }
/// ```
pub fn get(&self) -> Result<models::GetInfoResponse> {
let path = "/info".to_owned();
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
}
/// `client.installation_sync()`
#[derive(Clone, Copy)]
pub struct InstallationSyncResource<'a> {
client: &'a Client,
}
impl<'a> InstallationSyncResource<'a> {
/// Synchronize Directory-managed OIDC configuration
///
/// `POST /installation-sync/oidc`
///
/// Applies a Directory-signed OIDC configuration to the dedicated ChurchTools Identity provider. This public endpoint trusts only locally provisioned signing keys and uses monotonic revisions.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostInstallationSyncOidcBody {
/// configuration_token: "abc123".into(),
/// ..Default::default()
/// };
/// let installation_sync = client.installation_sync().oidc(&body)?;
/// println!("{:?}", installation_sync.external_login_id);
/// # Ok(())
/// # }
/// ```
pub fn oidc(&self, body: &models::PostInstallationSyncOidcBody) -> Result<models::PostInstallationSyncOidcData> {
let path = "/installation-sync/oidc".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.job_log()`
#[derive(Clone, Copy)]
pub struct JobLogResource<'a> {
client: &'a Client,
}
impl<'a> JobLogResource<'a> {
/// Get diagnostic entries for a job
///
/// `GET /joblog`
///
/// Returns log entries for an exact job identifier. An unknown identifier returns an empty array. Results are not paginated or ordered.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-joblog");
/// let query = GetJoblogQuery {
/// guid: Some("d038d398-c8e1-4c95-a3ad-c725dc6d4537-unchanged".into()),
/// ..Default::default()
/// };
/// for job_log in client.job_log().list(&query)? {
/// println!("{}", job_log.element_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetJoblogQuery) -> Result<Vec<models::JobLogEntry>> {
let path = "/joblog".to_owned();
let query: Query = query.to_query();
self.client.request_json(Method::Get, &path, &query, None)
}
}
/// `client.jobs()`
#[derive(Clone, Copy)]
pub struct JobsResource<'a> {
client: &'a Client,
}
impl<'a> JobsResource<'a> {
/// List background jobs
///
/// `GET /jobs`
///
/// Lists persisted background jobs, newest creation time first. Requires "administer settings" permission in `churchcore`. All supplied filters are combined with AND; status/domain ID lists match any contained value. Empty lists add no restriction. No pagination or result limit is implemented.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-jobs");
/// for job in client.jobs().list()? {
/// println!("{}", job.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Job>> {
self.list_with(&Default::default())
}
/// List background jobs
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /jobs`
///
/// Lists persisted background jobs, newest creation time first. Requires "administer settings" permission in `churchcore`. All supplied filters are combined with AND; status/domain ID lists match any contained value. Empty lists add no restriction. No pagination or result limit is implemented.
pub fn list_with(&self, query: &GetJobsQuery) -> Result<Vec<models::Job>> {
let path = "/jobs".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Append a background-job log message
///
/// `POST /jobs/{identifier}/logs`
///
/// Appends an application log entry for an existing background job. Requires "administer settings" permission in `churchcore`. Returns no response body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::JobLogCreate {
/// log_message: "Processed 25 records.".into(),
/// ..Default::default()
/// };
/// client.jobs().logs("1a9e9b86-78ee-4c8a-bf58-51e653073a0c", &body)?;
/// # Ok(())
/// # }
/// ```
pub fn logs(&self, identifier: impl Display, body: &models::JobLogCreate) -> Result<()> {
let path = format!("/jobs/{}/logs", seg(identifier));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Update a background-job status
///
/// `PUT /jobs/{identifier}/status`
///
/// Updates the stored job status. For `sync_job` jobs, "view" permission in `churchsync` is required; other jobs require "administer settings" permission in `churchcore`. This endpoint does not start or stop a worker.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::JobStatusUpdate {
/// status: "QUEUED".into(),
/// ..Default::default()
/// };
/// client.jobs().update_status("1a9e9b86-78ee-4c8a-bf58-51e653073a0c", &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update_status(&self, identifier: impl Display, body: &models::JobStatusUpdate) -> Result<()> {
let path = format!("/jobs/{}/status", seg(identifier));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.labels()`
#[derive(Clone, Copy)]
pub struct LabelsResource<'a> {
client: &'a Client,
}
impl<'a> LabelsResource<'a> {
/// Create an address-label PDF
///
/// `POST /labels`
///
/// Generates and stores a PDF of address labels, returning an absolute download URL. Labels use the configured German address formatter and one of three A4 layouts. Only visible selected persons are included; individual printable fields are checked against security levels. Incomplete addresses are still included. With combineSpouses=true, selected visible spouses may share a label even when their addresses differ; the first spouse with a complete address is preferred. Birthday sorting forces separate labels. PDF files are scheduled to expire after one day. The generation handler checks person visibility but has no explicit create print labels permission check; the labels file-download handler checks that permission. Input is currently read without the shared request validator, so malformed input can cause server errors.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::LabelCreate {
/// person_ids: serde_json::json!([42]),
/// r#type: "AveryLabels3475".into(),
/// ..Default::default()
/// };
/// let result = client.labels().create(&body)?;
/// println!("{}", result.pdf);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::LabelCreate) -> Result<models::PostLabelsData> {
let path = "/labels".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Count address labels
///
/// `POST /labels/totals`
///
/// Calculates four label counts for visible selected persons without generating a PDF. ignoreAddress includes incomplete addresses; onlyCompleteAddress requires street, postal code and city, but not country or address addition. Each contains the count with separate persons and after spouse grouping. Both spouses must be in the visible selection, but their addresses need not match. These counts do not take sortpolicy or layout into account; birthday PDF sorting always uses separate labels. Stored field completeness is checked before any printable-field security filtering.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-labels-totals");
/// let body = models::LabelTotalsRequest {
/// person_ids: serde_json::json!([42]),
/// ..Default::default()
/// };
/// let label = client.labels().totals(&body)?;
/// println!("{:?}", label);
/// # Ok(())
/// # }
/// ```
pub fn totals(&self, body: &models::LabelTotalsRequest) -> Result<models::LabelTotals> {
let path = "/labels/totals".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.languages()`
#[derive(Clone, Copy)]
pub struct LanguagesResource<'a> {
client: &'a Client,
}
impl<'a> LanguagesResource<'a> {
/// Get all languages
///
/// `GET /languages`
///
/// The response is a list of all languages
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-languages");
/// for language in client.languages().list()? {
/// println!("{}", language.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Language>> {
self.list_with(&Default::default())
}
/// Get all languages
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /languages`
///
/// The response is a list of all languages
pub fn list_with(&self, query: &GetLanguagesQuery) -> Result<Vec<models::Language>> {
let path = "/languages".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.license()`
#[derive(Clone, Copy)]
pub struct LicenseResource<'a> {
client: &'a Client,
}
impl<'a> LicenseResource<'a> {
/// Fetch license information
///
/// `GET /license/fetch`
///
/// Fetches and stores the current license information.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.license().get_fetch()?;
/// # Ok(())
/// # }
/// ```
pub fn get_fetch(&self) -> Result<()> {
let path = "/license/fetch".to_owned();
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
}
/// `client.login()`
#[derive(Clone, Copy)]
pub struct LoginResource<'a> {
client: &'a Client,
}
impl<'a> LoginResource<'a> {
pub fn two_factor(&self) -> LoginTwoFactorResource<'a> {
LoginTwoFactorResource { client: self.client }
}
/// Start password-based login
///
/// `POST /login`
///
/// Verifies a username/email and password, using configured LDAP authentication before local credentials. The configured default-login policy is enforced. HTTP 200 may mean login succeeded or that a second step is required; inspect data.status. With totp, submit the code and personId to POST /login/totp. With twoFactorSetup, initialize and activate two-factor setup before login is completed. Preserve cookies across all steps. rememberMe controls persistent browser login. Invalid credentials and locked accounts return 400, not 401. Failed local attempts increment account counters. All login steps share the configured login rate limit.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::LoginCreate {
/// password: "example-password".into(),
/// username: "alex@example.org".into(),
/// ..Default::default()
/// };
/// let result = client.login().create(&body)?;
/// println!("{:?}", result.location);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::LoginCreate) -> Result<models::LoginResult> {
let path = "/login".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get or create a persistent login token
///
/// `POST /login/token`
///
/// Verifies username/email and password and returns the person’s existing persistent login token, creating one only if none exists. No browser login is completed by this operation. The configured default-login policy applies. Accounts with activated two-factor authentication are rejected with 400. Token retrieval is blocked during non-support simulation. The returned credential has no expiry field and remains independent of logout. Failed credential checks can increment local account error counters. This route shares the configured login rate limit with the other login steps.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::LoginCredentials {
/// password: "example-password".into(),
/// username: "alex@example.org".into(),
/// ..Default::default()
/// };
/// let login = client.login().token(&body)?;
/// println!("{}", login.person_id);
/// # Ok(())
/// # }
/// ```
pub fn token(&self, body: &models::LoginCredentials) -> Result<models::LoginTokenResult> {
let path = "/login/token".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Complete login with an authenticator code
///
/// `POST /login/totp`
///
/// Verifies the authenticator code for the person bound to the pending password-verified session. Retain the same session cookie from POST /login; this operation does not use ordinary API authentication to select a person. On success the code is temporarily blacklisted, login is completed and the pending session is removed. A pending external-account link is completed instead when that context exists. If two-factor authentication was disabled or its secret disappeared after the password step, the legacy normal-login branch returns success without redirectTo and without completing login; clients should restart the login flow. Invalid or reused codes, missing pending session and person mismatch return 400. Shares the login rate limit.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::LoginTotpVerify {
/// code: "012345".into(),
/// person_id: 42,
/// ..Default::default()
/// };
/// let login = client.login().totp(&body)?;
/// println!("{:?}", login.redirect_to);
/// # Ok(())
/// # }
/// ```
pub fn totp(&self, body: &models::LoginTotpVerify) -> Result<models::TwoFactorLoginResult> {
let path = "/login/totp".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.login().two_factor()`
#[derive(Clone, Copy)]
pub struct LoginTwoFactorResource<'a> {
client: &'a Client,
}
impl<'a> LoginTwoFactorResource<'a> {
pub fn setup(&self) -> LoginTwoFactorSetupResource<'a> {
LoginTwoFactorSetupResource { client: self.client }
}
}
/// `client.login().two_factor().setup()`
#[derive(Clone, Copy)]
pub struct LoginTwoFactorSetupResource<'a> {
client: &'a Client,
}
impl<'a> LoginTwoFactorSetupResource<'a> {
/// Activate authenticator and complete required setup
///
/// `POST /login/twofactor/setup/activate`
///
/// Verifies a code from the secret initialized through POST /login/twofactor/setup in the same pending login session. The session identifies the person. On success, blacklists the code, enables two-factor authentication, completes browser login using the original rememberMe choice, and clears the pending session. The response includes a navigation target from that session. Invalid/reused codes, missing secret or missing setup session return 400. Activation is saved before browser login finishes, so a later failure can leave two-factor authentication enabled. This endpoint is not an idempotent status-setting operation; after success the pending session is gone. Shares the login rate limit.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TwoFactorSetupActivate {
/// code: "012345".into(),
/// ..Default::default()
/// };
/// let setup = client.login().two_factor().setup().activate(&body)?;
/// println!("{}", setup.redirect_to);
/// # Ok(())
/// # }
/// ```
pub fn activate(&self, body: &models::TwoFactorSetupActivate) -> Result<models::PostLoginTwofactorSetupActivateData> {
let path = "/login/twofactor/setup/activate".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Initialize required authenticator setup
///
/// `POST /login/twofactor/setup`
///
/// Starts authenticator enrollment for the person in a pending twoFactorSetup login session. Use the same cookies as the password step. Creates and stores a new secret and sets the enabled flag to false. Returns the secret and its QR-code image as a data URI. Repeating this request replaces the previous secret and invalidates its QR code, so do not use it as a read-only setup-status request. Submit a code generated from this secret to POST /login/twofactor/setup/activate. A missing or unsuitable pending session returns 400. Shares the login rate limit.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let result = client.login().two_factor().setup().create()?;
/// println!("{}", result.qrcode);
/// # Ok(())
/// # }
/// ```
pub fn create(&self) -> Result<models::TwoFactorSetupSecret> {
let path = "/login/twofactor/setup".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
}
/// `client.logout()`
#[derive(Clone, Copy)]
pub struct LogoutResource<'a> {
client: &'a Client,
}
impl<'a> LogoutResource<'a> {
/// End the current browser session
///
/// `POST /logout`
///
/// Deletes the current session cookie, destroys the server-side session and resets the current user to anonymous. Also usable to leave a pending two-factor login. This affects the current session only; it does not revoke persistent login tokens or OAuth tokens. A subsequent request still carrying such an Authorization header may authenticate again. An unauthenticated request without an applicable session may be rejected by authentication middleware.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.logout().create()?;
/// # Ok(())
/// # }
/// ```
pub fn create(&self) -> Result<()> {
let path = "/logout".to_owned();
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
}
/// `client.logs()`
#[derive(Clone, Copy)]
pub struct LogsResource<'a> {
client: &'a Client,
}
impl<'a> LogsResource<'a> {
pub fn statistics(&self) -> LogsStatisticsResource<'a> {
LogsStatisticsResource { client: self.client }
}
/// Get a log message
///
/// `GET /logs/{id}`
///
/// Fetch one specific log message by its ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-logs-id");
/// let log = client.logs().get(1)?;
/// println!("{}", log.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::Log> {
let path = format!("/logs/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all log messages
///
/// `GET /logs`
///
/// The response is a collection of all log messages you may see and is limited to a specific number of messages. You can use the `page` parameter to browse the list of log messages. The logs are ordered by date.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-logs");
/// for log in client.logs().list()? {
/// println!("{}", log.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Log>> {
self.list_with(&Default::default())
}
/// Get all log messages
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /logs`
///
/// The response is a collection of all log messages you may see and is limited to a specific number of messages. You can use the `page` parameter to browse the list of log messages. The logs are ordered by date.
pub fn list_with(&self, query: &GetLogsQuery) -> Result<Vec<models::Log>> {
let path = "/logs".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all log messages
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetLogsQuery) -> Items<models::Log> {
let path = "/logs".to_owned();
self.client.items(&path, query.to_query())
}
}
/// `client.logs().statistics()`
#[derive(Clone, Copy)]
pub struct LogsStatisticsResource<'a> {
client: &'a Client,
}
impl<'a> LogsStatisticsResource<'a> {
/// `GET /logs/statistics/login`
///
/// Get statistics about login counts of users.
///
/// Use [`Self::list_login_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-logs-statistics-login");
/// for login in client.logs().statistics().list_login()? {
/// println!("{}", login.last_login);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_login(&self) -> Result<Vec<models::GetLogsStatisticsLoginDataItem>> {
self.list_login_with(&Default::default())
}
/// `GET /logs/statistics/login`
///
/// Like [`Self::list_login`], with query parameters.
///
/// Get statistics about login counts of users.
pub fn list_login_with(&self, query: &GetLogsStatisticsLoginQuery) -> Result<Vec<models::GetLogsStatisticsLoginDataItem>> {
let path = "/logs/statistics/login".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// `GET /logs/statistics/login`
///
/// Like [`Self::list_login_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_login_iter(&self, query: &GetLogsStatisticsLoginQuery) -> Items<models::GetLogsStatisticsLoginDataItem> {
let path = "/logs/statistics/login".to_owned();
self.client.items(&path, query.to_query())
}
}
/// `client.markdown()`
#[derive(Clone, Copy)]
pub struct MarkdownResource<'a> {
client: &'a Client,
}
impl<'a> MarkdownResource<'a> {
/// Validate Markdown string
///
/// `POST /markdown/check`
///
/// Check if the provided Markdown content is valid for the specified scope
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-markdown-check");
/// let body = models::PostMarkdownCheckBody {
/// input_scope: "description".into(),
/// markdown: "Hallo zusammen".into(),
/// ..Default::default()
/// };
/// let markdown = client.markdown().check(&body)?;
/// println!("{}", markdown.is_valid);
/// # Ok(())
/// # }
/// ```
pub fn check(&self, body: &models::PostMarkdownCheckBody) -> Result<models::PostMarkdownCheckData> {
let path = "/markdown/check".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Convert Markdown to HTML etc.
///
/// `POST /markdown/convert`
///
/// convert a set of markdown strings
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::MarkdownRequest {
/// sources: vec![models::MarkdownRequestSourcesItem {
/// input_scope: "description".into(),
/// markdown: "Hallo zusammen".into(),
/// output_formats: vec!["html".into()],
/// output_scopes: vec!["description".into()],
/// short_name: "Hauskreis Nord".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let markdown = client.markdown().convert(&body)?;
/// println!("{:?}", markdown.current_config_file);
/// # Ok(())
/// # }
/// ```
pub fn convert(&self, body: &models::MarkdownRequest) -> Result<models::Config> {
let path = "/markdown/convert".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
}
/// `client.master_data()`
#[derive(Clone, Copy)]
pub struct MasterDataResource<'a> {
client: &'a Client,
}
impl<'a> MasterDataResource<'a> {
/// Fetch all master data for the module "People & Groups"
///
/// `GET /masterdata/person`
///
/// Deprecated alias of `GET /person/masterdata`. Use `/person/masterdata` for new integrations.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-masterdata-person");
/// let person = client.master_data().get_person()?;
/// println!("{:?}", person);
/// # Ok(())
/// # }
/// ```
#[deprecated = "GET /masterdata/person is deprecated in the ChurchTools API. Use `/person/masterdata` for new integrations."]
pub fn get_person(&self) -> Result<models::PersonMasterData> {
let path = "/masterdata/person".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.meeting_requests()`
#[derive(Clone, Copy)]
pub struct MeetingRequestsResource<'a> {
client: &'a Client,
}
impl<'a> MeetingRequestsResource<'a> {
/// Handle ICS reply for meeting requests
///
/// `POST /meetingrequests/reply`
///
/// Processes an external calendar reply using the invitation reply token. ACCEPTED and DECLINED replies can notify the inviter.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::MeetingRequestIcsReply {
/// ics_content: "Hallo zusammen".into(),
/// partstat: "ACCEPTED".into(),
/// token: "example-reply-token".into(),
/// ..Default::default()
/// };
/// client.meeting_requests().reply(&body)?;
/// # Ok(())
/// # }
/// ```
pub fn reply(&self, body: &models::MeetingRequestIcsReply) -> Result<()> {
let path = "/meetingrequests/reply".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.menu()`
#[derive(Clone, Copy)]
pub struct MenuResource<'a> {
client: &'a Client,
}
impl<'a> MenuResource<'a> {
/// Get the CT-Menu
///
/// `GET /menu`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-menu");
/// let menu = client.menu().get()?;
/// println!("{:?}", menu.current_station);
/// # Ok(())
/// # }
/// ```
pub fn get(&self) -> Result<models::GetMenuResponse> {
let path = "/menu".to_owned();
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
}
/// `client.news_letter_integrations()`
#[derive(Clone, Copy)]
pub struct NewsLetterIntegrationsResource<'a> {
client: &'a Client,
}
impl<'a> NewsLetterIntegrationsResource<'a> {
/// Get newsletter integration options
///
/// `GET /newsletter-integrations`
///
/// Lists active configured newsletter providers, their capabilities and available remote lists. Requires administer groups in churchgroup; this is not a public endpoint. Queries the providers and marks lists already mapped to any group with isAssigned, including groups outside the caller’s individual visibility. Assigned lists are not removed from the result. A caught provider exception is logged and represented as an empty lists array, with HTTP 200 and no per-provider error field. No providers yields data: \[\] and meta.count: 0. Results follow provider registration order and are not paginated.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-newsletter-integrations");
/// for news_letter_integration in client.news_letter_integrations().list()? {
/// println!("{}", news_letter_integration.can_create_lists);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::NewsletterIntegrationOptions>> {
let path = "/newsletter-integrations".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.notes()`
#[derive(Clone, Copy)]
pub struct NotesResource<'a> {
client: &'a Client,
}
impl<'a> NotesResource<'a> {
/// Create a note attached to an object
///
/// `POST /notes/{domainType}/{domainId}`
///
/// Creates a note linked to the object in the URL. Group notes require an existing group and group-note editing rights. Arrangement notes require "edit songcategory" permission for the parent song’s category. Person notes require person visibility, permission for the selected comment-viewer category, and person write or applicable group-member field-edit permission. Direct creation for `follow_up` is rejected; use the follow-up note API.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-notes-domainType-domainId");
/// let body = models::NoteCreate {
/// text: "Please follow up next week.".into(),
/// ..Default::default()
/// };
/// let result = client.notes().create("group", 35, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, domain_type: impl Display, domain_id: impl Display, body: &models::NoteCreate) -> Result<models::Note> {
let path = format!("/notes/{}/{}", seg(domain_type), seg(domain_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a note and all its links
///
/// `DELETE /notes/{noteId}`
///
/// Deletes the note from every linked business object. Authors can delete their notes without a fresh object-access check. Non-authors need global `churchdb` write access, and the first stored link must be a person link; person and comment visibility are not checked. Other domains do not allow non-author deletion. `DELETE /notes/{domainType}/{domainId}/{noteId}` is an equivalent alias whose domain path fields are ignored.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.notes().delete(101)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, note_id: impl Display) -> Result<()> {
let path = format!("/notes/{}", seg(note_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Delete a note and all its links
///
/// `DELETE /notes/{domainType}/{domainId}/{noteId}`
///
/// Deletes the note and all its links, not only the link named in the URL. The handler ignores `domainType` and `domainId`. Authors can delete their notes without a fresh domain-access check. Non-authors need global `churchdb` write access, and the first stored link must be a person link; person and comment visibility are not checked. Other domains do not allow non-author deletion. `DELETE /notes/{noteId}` calls the same handler.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.notes().delete_for_object("group", "42", 101)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_for_object(&self, domain_type: impl Display, domain_id: impl Display, note_id: impl Display) -> Result<()> {
let path = format!("/notes/{}/{}/{}", seg(domain_type), seg(domain_id), seg(note_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// List visible notes attached to an object
///
/// `GET /notes/{domainType}/{domainId}`
///
/// Lists notes linked to the requested object, newest creation date first, without pagination. Group notes require group visibility and a sufficient security level, person notes require comment-viewer permission, arrangement notes require parent-song visibility, and follow-up notes require access to the follow-up. Authors bypass the group security-level or person comment-category filter after the initial domain check. Person notes do not check the requested person’s visibility or existence. Each note includes all links and uses its first stored link for top-level domain fields.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-notes");
/// for note in client.notes().get("group", 35)? {
/// println!("{}", note.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn get(&self, domain_type: impl Display, domain_id: impl Display) -> Result<Vec<models::Note>> {
let path = format!("/notes/{}/{}", seg(domain_type), seg(domain_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Replace an authored note’s text and visibility
///
/// `PUT /notes/{domainType}/{domainId}/{noteId}`
///
/// Updates a note owned by the current author. Only `noteId` selects the note; `domainId` does not verify its association. The shared text changes for every linked context, while visibility changes only on the first link matching `domainType`. No fresh domain or comment-category permission check is performed.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-notes-domainType-domainId-id");
/// let body = models::NoteUpdate {
/// text: "Please follow up next week.".into(),
/// ..Default::default()
/// };
/// let result = client.notes().update("group", 35, 101, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, domain_type: impl Display, domain_id: impl Display, note_id: impl Display, body: &models::NoteUpdate) -> Result<models::Note> {
let path = format!("/notes/{}/{}/{}", seg(domain_type), seg(domain_id), seg(note_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.notifications()`
#[derive(Clone, Copy)]
pub struct NotificationsResource<'a> {
client: &'a Client,
}
impl<'a> NotificationsResource<'a> {
/// Send a test push notification to my devices
///
/// `POST /notifications/test`
///
/// Sends a localized test push notification to the authenticated person’s registered push-capable devices. No request body or target person is needed. The response has no body. A 201 response does not confirm delivery: it is also returned when no device is registered, Safe Mode suppresses sending, or a handled proxy/network error occurs.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.notifications().test()?;
/// # Ok(())
/// # }
/// ```
pub fn test(&self) -> Result<()> {
let path = "/notifications/test".to_owned();
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
}
/// `client.nps()`
#[derive(Clone, Copy)]
pub struct NpsResource<'a> {
client: &'a Client,
}
impl<'a> NpsResource<'a> {
/// Save NPS score
///
/// `POST /nps`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostNpsBody {
/// score: 42,
/// ..Default::default()
/// };
/// let result = client.nps().create(&body)?;
/// println!("{:?}", result.date);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::PostNpsBody) -> Result<models::PostNpsResponse> {
let path = "/nps".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
}
/// `client.oauth_clients()`
#[derive(Clone, Copy)]
pub struct OauthClientsResource<'a> {
client: &'a Client,
}
impl<'a> OauthClientsResource<'a> {
/// Register an OAuth client
///
/// `POST /oauthclients`
///
/// Registers a visible OAuth client for an application that uses ChurchTools as its authorization server. Requires "churchcore administer settings" permission. The name must be unique, including hidden clients. Confidential clients receive a generated secret exactly once. Logo discovery can contact the redirect origin or configured metadata service.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-oauthclients");
/// let body = models::OAuthClientCreate {
/// name: "Parish website".into(),
/// redirect_uri: "https://parish.example.org/oauth/callback".into(),
/// ..Default::default()
/// };
/// let result = client.oauth_clients().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::OAuthClientCreate) -> Result<models::OAuthClientCreated> {
let path = "/oauthclients".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete an OAuth client
///
/// `DELETE /oauthclients/{identifier}`
///
/// Permanently deletes a visible OAuth client. Requires "churchcore administer settings" permission. Database cascades remove associated authorization codes, access tokens and consents. Hidden clients cannot be managed through this endpoint.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.oauth_clients().delete("abc123")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, identifier: impl Display) -> Result<()> {
let path = format!("/oauthclients/{}", seg(identifier));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// List registered OAuth clients
///
/// `GET /oauthclients`
///
/// Lists visible OAuth clients registered in this ChurchTools installation, without pagination or an explicit sort order. Requires "churchcore administer settings" permission. Client secrets and hashes are not included.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-oauthclients");
/// for oauth_client in client.oauth_clients().list()? {
/// println!("{}", oauth_client.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::OAuthClient>> {
let path = "/oauthclients".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update an OAuth client
///
/// `PUT /oauthclients/{identifier}`
///
/// Replaces the name and registered redirect URI of a visible OAuth client. Requires "churchcore administer settings" permission. The URI replaces all previously registered URI entries. The name must remain unique across visible and hidden clients. Logo discovery runs again from the new URI origin.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-oauthclients-identifier");
/// let body = models::OAuthClientUpdate {
/// name: "Parish website".into(),
/// redirect_uri: "https://parish.example.org/oauth/callback".into(),
/// ..Default::default()
/// };
/// let result = client.oauth_clients().update("abc123", &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, identifier: impl Display, body: &models::OAuthClientUpdate) -> Result<models::OAuthClient> {
let path = format!("/oauthclients/{}", seg(identifier));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.permissions()`
#[derive(Clone, Copy)]
pub struct PermissionsResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsResource<'a> {
pub fn global(&self) -> PermissionsGlobalResource<'a> {
PermissionsGlobalResource { client: self.client }
}
pub fn internal(&self) -> PermissionsInternalResource<'a> {
PermissionsInternalResource { client: self.client }
}
pub fn origins(&self) -> PermissionsOriginsResource<'a> {
PermissionsOriginsResource { client: self.client }
}
/// Apply multiple raw permission changes atomically
///
/// `POST /permissions/bulk`
///
/// Applies raw permission changes atomically, including changes for different source owners. All entries are validated and authorized against the state before any writes. The authorization and locked-permission rules of the corresponding single-assignment operations apply to each entry. Any failure leaves all assignments unchanged. Duplicate owner/authId/inheritance keys are rejected. Permission caches are invalidated after commit. `save` is additive and an empty dataId list writes a null-data row; `replace` replaces the complete selection and an empty list removes it; `delete` removes exact selections or the whole assignment when no selections are specified. Validation errors identify fields such as `changes.2.authId`.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostPermissionsBulkBody {
/// changes: vec![models::PermissionBulkChange {
/// domain_id: 7,
/// domain_type: "group_type_role".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// client.permissions().bulk(&body)?;
/// # Ok(())
/// # }
/// ```
pub fn bulk(&self, body: &models::PostPermissionsBulkBody) -> Result<()> {
let path = "/permissions/bulk".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Delete a raw permission assignment
///
/// `DELETE /permissions/{domainType}/{domainId}`
///
/// Deletes stored assignment rows for the owner in the path, authId and inheritance mode. Requires administer persons in churchcore, or specifically a group_role assignment for authId 10130/10131 plus churchdb +admin posts in that role’s actual group. Locked selections may only be changed by an authorized person. Omitting dataId, null or \[\] removes all selection rows in the chosen inheritance mode; a nonempty list deletes exact selections. -1 does not expand to concrete rows. type/reason do not filter deletion, so both grants and revocations matching the key are removed. Other assignment sources remain effective. Missing rows are harmless. The generic admin path does not verify the owner or permission definition exists, except obsolete authId=10127 returns 410. status/person disallow authId>=10000 and inheritance. The current deletion path does not explicitly invalidate the permission cache.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PermissionDelete {
/// auth_id: 10130,
/// ..Default::default()
/// };
/// client.permissions().delete("group_role", 1, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, domain_type: impl Display, domain_id: impl Display, body: &models::PermissionDelete) -> Result<()> {
let path = format!("/permissions/{}/{}", seg(domain_type), seg(domain_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Delete, &path, &query, Some(&body)).map(|_| ())
}
/// List permission definitions
///
/// `GET /permissions/definitions`
///
/// Returns registered permission definitions grouped by module. Requires administer persons in churchcore. global selects keys without a leading +; internal selects group-internal keys beginning with +; all includes both. Definitions explain assignable keys, not the current user’s effective permissions. Modules follow application ordering and modules without matching definitions are omitted. For data-field permissions, selections starts with dataId=-1 for unrestricted access to current and future values. Other selections come from the configured catalog without per-object visibility filtering. name and description currently contain the same text, and assignmentDomains is a fixed generic list. The response is not paginated.
///
/// Use [`Self::get_definitions_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-definitions");
/// let definition = client.permissions().get_definitions()?;
/// println!("{:?}", definition);
/// # Ok(())
/// # }
/// ```
pub fn get_definitions(&self) -> Result<models::GetPermissionsDefinitionsData> {
self.get_definitions_with(&Default::default())
}
/// List permission definitions
///
/// Like [`Self::get_definitions`], with query parameters.
///
/// `GET /permissions/definitions`
///
/// Returns registered permission definitions grouped by module. Requires administer persons in churchcore. global selects keys without a leading +; internal selects group-internal keys beginning with +; all includes both. Definitions explain assignable keys, not the current user’s effective permissions. Modules follow application ordering and modules without matching definitions are omitted. For data-field permissions, selections starts with dataId=-1 for unrestricted access to current and future values. Other selections come from the configured catalog without per-object visibility filtering. name and description currently contain the same text, and assignmentDomains is a fixed generic list. The response is not paginated.
pub fn get_definitions_with(&self, query: &GetPermissionsDefinitionsQuery) -> Result<models::GetPermissionsDefinitionsData> {
let path = "/permissions/definitions".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List locked permissions
///
/// `GET /permissions/locked`
///
/// Lists all stored permission locks, ordered by permission ID and selection ID. Requires administer persons in churchcore, but the caller need not be an authorized contact person. A lock restricts assigning or removing the selected permission across assignment domains; it does not revoke existing grants or disable their use. Only authorized persons may change locked assignments. Locks can refer to global or group-internal permission keys. The response includes whether the current person is on the installation’s authorized-person list. Stored locks are returned without filtering inactive/obsolete definitions, and the result is not paginated.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-locked");
/// let locked = client.permissions().get_locked()?;
/// println!("{}", locked.is_current_user_authorized_person);
/// # Ok(())
/// # }
/// ```
pub fn get_locked(&self) -> Result<models::LockedPermissionState> {
let path = "/permissions/locked".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List permissions for a domain object
///
/// `GET /permissions/{domainType}/{domainId}`
///
/// Lists raw assignments for one source object. status/person address a person-status or person ID; group_type_role/group_role address their role IDs. group_type collects role-template assignments of that group type; group combines concrete group-role and associated group-type-role assignments, preserving each row’s actual owner domain and ID. Only permission IDs in the currently loaded active definition table are returned. No pagination, explicit ordering, or object-existence check is applied; an unknown owner normally returns an empty list. Intended access is administer persons in churchcore, with a restricted post-administration fallback. The current fallback passes an incomplete key to a boolean permission check and ignores its result; enabled assertions may fail the request. Otherwise direct-domain views restrict authIds to 10130/10131, but combined group/group_type views omit that restriction. This defect must not be treated as an authorization guarantee.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-permissionDomainType-permissionDomainId");
/// for permission in client.permissions().list("person", 1)? {
/// println!("{}", permission.auth_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, domain_type: impl Display, domain_id: impl Display) -> Result<Vec<models::Permission>> {
let path = format!("/permissions/{}/{}", seg(domain_type), seg(domain_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Search selectable permission assignment targets
///
/// `GET /permissions/assignment-targets`
///
/// Requires "administer persons" in churchcore. Lists statuses, group-type role templates, concrete group roles, and persons, independently of existing assignments. Archived and inactive targets are included. Without query, lists all targets. Every whitespace-separated search word must match part of the name or its group/group-type context, irrespective of word order. SQL wildcard characters are treated literally. Results use one global pagination, ordered by category (status, group_type_role, group_role, person), name, context name, and domainId. Later categories can therefore start on later pages. Selection does not authorize assigning a specific permission; write endpoints check that separately. Group and role context is returned only for role targets.
///
/// Use [`Self::list_assignment_targets_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-assignment-targets");
/// for assignment_target in client.permissions().list_assignment_targets()? {
/// println!("{}", assignment_target.domain_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_assignment_targets(&self) -> Result<Vec<models::PermissionAssignmentTarget>> {
self.list_assignment_targets_with(&Default::default())
}
/// Search selectable permission assignment targets
///
/// Like [`Self::list_assignment_targets`], with query parameters.
///
/// `GET /permissions/assignment-targets`
///
/// Requires "administer persons" in churchcore. Lists statuses, group-type role templates, concrete group roles, and persons, independently of existing assignments. Archived and inactive targets are included. Without query, lists all targets. Every whitespace-separated search word must match part of the name or its group/group-type context, irrespective of word order. SQL wildcard characters are treated literally. Results use one global pagination, ordered by category (status, group_type_role, group_role, person), name, context name, and domainId. Later categories can therefore start on later pages. Selection does not authorize assigning a specific permission; write endpoints check that separately. Group and role context is returned only for role targets.
pub fn list_assignment_targets_with(&self, query: &GetPermissionsAssignmentTargetsQuery) -> Result<Vec<models::PermissionAssignmentTarget>> {
let path = "/permissions/assignment-targets".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Search selectable permission assignment targets
///
/// Like [`Self::list_assignment_targets_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_assignment_targets_iter(&self, query: &GetPermissionsAssignmentTargetsQuery) -> Items<models::PermissionAssignmentTarget> {
let path = "/permissions/assignment-targets".to_owned();
self.client.items(&path, query.to_query())
}
/// List permissions for a domain type
///
/// `GET /permissions/{domainType}`
///
/// Lists stored permission assignments in one source domain; these are raw grants/revocations, not effective permissions. Optional domainId filters a specific assignment owner. group_type and group are combined read views and require domainId even on this short route; omitting it returns a validation error. group_type lists its role-template assignments, while group combines concrete group-role and corresponding group-type-role assignments. Returned rows retain their actual role domain/ID. Only authIds present in the currently loaded active definition table are included. No pagination, object-existence check or explicit ordering is applied. Intended access is administer persons in churchcore, with a limited post-administration fallback. That fallback currently uses an incomplete permission key and ignores its boolean result; with assertions enabled it may fail, and otherwise combined views are not restricted to the two post-creation authIds. Do not rely on this behavior as an authorization guarantee.
///
/// Use [`Self::list_for_type_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-permissionDomainType");
/// for for_type in client.permissions().list_for_type("person")? {
/// println!("{}", for_type.auth_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_for_type(&self, domain_type: impl Display) -> Result<Vec<models::Permission>> {
self.list_for_type_with(domain_type, &Default::default())
}
/// List permissions for a domain type
///
/// Like [`Self::list_for_type`], with query parameters.
///
/// `GET /permissions/{domainType}`
///
/// Lists stored permission assignments in one source domain; these are raw grants/revocations, not effective permissions. Optional domainId filters a specific assignment owner. group_type and group are combined read views and require domainId even on this short route; omitting it returns a validation error. group_type lists its role-template assignments, while group combines concrete group-role and corresponding group-type-role assignments. Returned rows retain their actual role domain/ID. Only authIds present in the currently loaded active definition table are included. No pagination, object-existence check or explicit ordering is applied. Intended access is administer persons in churchcore, with a limited post-administration fallback. That fallback currently uses an incomplete permission key and ignores its boolean result; with assertions enabled it may fail, and otherwise combined views are not restricted to the two post-creation authIds. Do not rely on this behavior as an authorization guarantee.
pub fn list_for_type_with(&self, domain_type: impl Display, query: &GetPermissionsPermissionDomainTypeQuery) -> Result<Vec<models::Permission>> {
let path = format!("/permissions/{}", seg(domain_type));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Save a raw permission assignment
///
/// `PUT /permissions/{domainType}/{domainId}`
///
/// Adds or updates raw permission assignments for the source owner in the path. Requires administer persons in churchcore, or a group_role assignment for authId 10130/10131 and churchdb +admin posts in that role’s actual group. Locked selections additionally require an authorized person. type defaults to grant; revoke is only supported for group_role. Only role domains allow inheritance and internal authIds; status/person require authId<10000. Obsolete authId=10127 returns 410. dataId is an additive list: other existing selections remain. Omission, null or \[\] writes a null-data row, not an unrestricted grant; use \[-1\] for unrestricted selections. Currently any existing -1 row for the key/inheritance mode causes a nonempty-list update to be silently ignored, including reason/type changes. The general admin path does not validate owner, permission-definition or selection existence. Success returns 204 without a representation; it does not necessarily mean a row changed.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PermissionUpdate {
/// auth_id: 10130,
/// ..Default::default()
/// };
/// client.permissions().update("group_role", 1, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, domain_type: impl Display, domain_id: impl Display, body: &models::PermissionUpdate) -> Result<()> {
let path = format!("/permissions/{}/{}", seg(domain_type), seg(domain_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
/// Update locked permissions
///
/// `PUT /permissions/locked`
///
/// Adds and removes permission locks in one transaction. Requires both administer persons in churchcore and membership in the installation’s authorized-person list. Both add and remove are required; empty lists are allowed. Duplicates are collapsed, existing additions and missing removals are harmless, but the same normalized pair in both lists returns 400. This is a delta update, not full replacement. Each authId must exist in the definition table loaded for the request. Boolean permissions require omitted/null dataId; selectable permissions require a non-null dataId. Concrete selection existence and range are currently not checked. Locks may concern internal or global permissions; -1 locks all values. Existing grants are not revoked. Returns the complete resulting list under data.permissions, without the authorization flag returned by GET.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::LockedPermissionUpdate {
/// add: vec![models::LockedPermissionChange {
/// auth_id: 1,
/// ..Default::default()
/// }],
/// remove: vec![models::LockedPermissionChange {
/// auth_id: 1,
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.permissions().update_locked(&body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update_locked(&self, body: &models::LockedPermissionUpdate) -> Result<models::PutPermissionsLockedData> {
let path = "/permissions/locked".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
/// Replace a raw permission assignment
///
/// `PUT /permissions/{domainType}/{domainId}/replace`
///
/// Atomically replaces all raw assignment rows for the source owner, authId and inheritance mode. A nonempty dataId list becomes the complete selection; an empty list removes the assignment. The authorization, domain and locked-permission restrictions are the same as for updating and deleting the corresponding raw assignment.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PermissionReplace {
/// auth_id: 10130,
/// data_id: vec![1, 2],
/// ..Default::default()
/// };
/// client.permissions().update_replace("group_role", 1, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update_replace(&self, domain_type: impl Display, domain_id: impl Display, body: &models::PermissionReplace) -> Result<()> {
let path = format!("/permissions/{}/{}/replace", seg(domain_type), seg(domain_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.permissions().global_()`
#[derive(Clone, Copy)]
pub struct PermissionsGlobalResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsGlobalResource<'a> {
pub fn auths(&self) -> PermissionsGlobalAuthsResource<'a> {
PermissionsGlobalAuthsResource { client: self.client }
}
/// Get the current user’s global permissions
///
/// `GET /permissions/global`
///
/// Returns effective global permission values for the authenticated user, grouped by active module. No permission-administration grant is required. Includes registered keys even without a grant: boolean flags are false and selection arrays are empty. A maximum-level permission is represented by a one-element array with the effective maximum; unrestricted maximum access uses 99999. Multi-selection grants expand unrestricted access into currently available IDs, so this response cannot distinguish unrestricted access from explicit grants to all current values. Inactive modules are absent; compatibility aliases in churchdb can be null when their source in churchgroup is absent. Use the definitions and origins endpoints for value semantics and assignment provenance. Group-internal permissions and additional object policies are not combined here.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-global");
/// let item = client.permissions().global().get()?;
/// println!("{:?}", item);
/// # Ok(())
/// # }
/// ```
pub fn get(&self) -> Result<models::GlobalPermissions> {
let path = "/permissions/global".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Summarize Persons with Global Permissions
///
/// `GET /permissions/global/person-summary`
///
/// Returns every registered global permission of active modules with per-selection counts across non-archived persons. Requires administer persons in churchcore; this administrative overview has no additional person-visibility filter and does not generally exclude system users. Includes zero-count selections. Boolean permissions have one dataId=null selection. Data-field permissions start with unrestricted dataId=-1, followed by configured IDs in ascending order. Maximum grants count toward every configured level up to the effective maximum; unrestricted counts only include grants covering future values. Preview arrays contain the first three matching person IDs in ascending order. Permissions follow definition order. Counts across selections can overlap. No pagination or full person lists are returned; load /permissions/global/auths/{authId}/persons for one selection.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-global-person-summary");
/// let person_summary = client.permissions().global().get_person_summary()?;
/// println!("{:?}", person_summary);
/// # Ok(())
/// # }
/// ```
pub fn get_person_summary(&self) -> Result<models::GetPermissionsGlobalPersonSummaryData> {
let path = "/permissions/global/person-summary".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.permissions().global_().auths()`
#[derive(Clone, Copy)]
pub struct PermissionsGlobalAuthsResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsGlobalAuthsResource<'a> {
/// Summarize assignments of a global permission
///
/// `GET /permissions/global/auths/{authId}/assignment-summary`
///
/// Summarizes assignment sources for one global permission selection across non-archived persons. Requires administer persons in churchcore; does not filter the population to persons individually visible to the caller. data_id is required for selectable permissions and forbidden for boolean permissions; -1 selects genuinely unrestricted grants. Status, group-type-role, group-role and direct-person assignments are grouped into separate lists. Counts are distinct within one entry and can overlap across entries. Logged-in defaults, public-user rights and super-admin status count toward effectivePersonCount but have no breakdown entries, so the total need not match the sum even without overlapping assignments. Revoked sources are excluded. Unknown, inactive or group-internal authId values return 404. The result is not paginated.
///
/// Use [`Self::get_assignment_summary_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-global-auths-authId-assignment-summary");
/// let assignment_summary = client.permissions().global().auths().get_assignment_summary(125)?;
/// println!("{}", assignment_summary.auth_id);
/// # Ok(())
/// # }
/// ```
pub fn get_assignment_summary(&self, auth_id: impl Display) -> Result<models::PermissionAssignmentSummary> {
self.get_assignment_summary_with(auth_id, &Default::default())
}
/// Summarize assignments of a global permission
///
/// Like [`Self::get_assignment_summary`], with query parameters.
///
/// `GET /permissions/global/auths/{authId}/assignment-summary`
///
/// Summarizes assignment sources for one global permission selection across non-archived persons. Requires administer persons in churchcore; does not filter the population to persons individually visible to the caller. data_id is required for selectable permissions and forbidden for boolean permissions; -1 selects genuinely unrestricted grants. Status, group-type-role, group-role and direct-person assignments are grouped into separate lists. Counts are distinct within one entry and can overlap across entries. Logged-in defaults, public-user rights and super-admin status count toward effectivePersonCount but have no breakdown entries, so the total need not match the sum even without overlapping assignments. Revoked sources are excluded. Unknown, inactive or group-internal authId values return 404. The result is not paginated.
pub fn get_assignment_summary_with(&self, auth_id: impl Display, query: &GetPermissionsGlobalAuthsAuthIdAssignmentSummaryQuery) -> Result<models::PermissionAssignmentSummary> {
let path = format!("/permissions/global/auths/{}/assignment-summary", seg(auth_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List Persons with a Global Permission
///
/// `GET /permissions/global/auths/{authId}/persons`
///
/// Lists non-archived persons with one effective global permission selection, in ascending numeric ID order. Requires administer persons in churchcore; there is no additional person-visibility filter or general exclusion of system users. Contributions from direct assignments, status, group roles, public-user rights, logged-in defaults and super-admin status are combined. For selectable permissions, data_id is required: a configured ID selects that value and -1 selects genuinely unrestricted access to current and future values. Maximum permissions match when their effective maximum reaches the requested value. For boolean permissions data_id must be omitted, and the selection has dataId=null. Unknown, inactive or internal authId values return 404; invalid/missing selections return 400. By default all matching IDs are returned. Supplying page, limit OR include=origins enables pagination, defaulting to page 1 and limit 50. include=origins adds contributing, non-revoked sources for each person on that page. Pagination metadata is inside data.meta.
///
/// Use [`Self::get_persons_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-global-auths-authId-persons");
/// let person = client.permissions().global().auths().get_persons(125)?;
/// println!("{}", person.auth_id);
/// # Ok(())
/// # }
/// ```
pub fn get_persons(&self, auth_id: impl Display) -> Result<models::PermissionPersons> {
self.get_persons_with(auth_id, &Default::default())
}
/// List Persons with a Global Permission
///
/// Like [`Self::get_persons`], with query parameters.
///
/// `GET /permissions/global/auths/{authId}/persons`
///
/// Lists non-archived persons with one effective global permission selection, in ascending numeric ID order. Requires administer persons in churchcore; there is no additional person-visibility filter or general exclusion of system users. Contributions from direct assignments, status, group roles, public-user rights, logged-in defaults and super-admin status are combined. For selectable permissions, data_id is required: a configured ID selects that value and -1 selects genuinely unrestricted access to current and future values. Maximum permissions match when their effective maximum reaches the requested value. For boolean permissions data_id must be omitted, and the selection has dataId=null. Unknown, inactive or internal authId values return 404; invalid/missing selections return 400. By default all matching IDs are returned. Supplying page, limit OR include=origins enables pagination, defaulting to page 1 and limit 50. include=origins adds contributing, non-revoked sources for each person on that page. Pagination metadata is inside data.meta.
pub fn get_persons_with(&self, auth_id: impl Display, query: &GetPermissionsGlobalAuthsAuthIdPersonsQuery) -> Result<models::PermissionPersons> {
let path = format!("/permissions/global/auths/{}/persons", seg(auth_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.permissions().internal()`
#[derive(Clone, Copy)]
pub struct PermissionsInternalResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsInternalResource<'a> {
pub fn events(&self) -> PermissionsInternalEventsResource<'a> {
PermissionsInternalEventsResource { client: self.client }
}
pub fn groups(&self) -> PermissionsInternalGroupsResource<'a> {
PermissionsInternalGroupsResource { client: self.client }
}
pub fn persons(&self) -> PermissionsInternalPersonsResource<'a> {
PermissionsInternalPersonsResource { client: self.client }
}
}
/// `client.permissions().internal().events()`
#[derive(Clone, Copy)]
pub struct PermissionsInternalEventsResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsInternalEventsResource<'a> {
/// Lookup event-related internal permissions
///
/// `GET /permissions/internal/events/{eventId}`
///
/// Calculates internal group permissions for the currently logged-in person from groups connected to service roles. internalPerms contains event-level grants, while serviceGroups and services are maps keyed by master-data IDs. Only granted keys appear and their values are `true`; an empty area is returned as \[\]. Role and service-group grants are collected across connected roles and do not require an assignment in this event.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-internal-events-eventId");
/// let event = client.permissions().internal().events().get(42)?;
/// println!("{:?}", event);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, event_id: impl Display) -> Result<models::InternalEventPermissions> {
let path = format!("/permissions/internal/events/{}", seg(event_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.permissions().internal().groups()`
#[derive(Clone, Copy)]
pub struct PermissionsInternalGroupsResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsInternalGroupsResource<'a> {
pub fn auths(&self) -> PermissionsInternalGroupsAuthsResource<'a> {
PermissionsInternalGroupsAuthsResource { client: self.client }
}
/// Get the current user’s internal permissions for a group
///
/// `GET /permissions/internal/groups/{groupId}`
///
/// Calculates the authenticated user’s group-internal permissions for the target group, including inherited grants from superior groups. Values are grouped by active module. Registered flags without grants are false; level/selection values without grants are 0. Maximum-level grants are integers (99999 for unrestricted), while multiple selections are integer arrays. No permission-administration grant or group-visibility check is performed, and the group is not loaded: an unknown group ID returns the default permission structure rather than 404. Global grants and object policies are separate, so this response is not a complete authorization decision. Unlike the all-groups endpoint, this response includes legacy +create posts, derived as the conjunction of internal and visible post-creation grants.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-internal-groups-groupId");
/// let group = client.permissions().internal().groups().get(42)?;
/// println!("{:?}", group);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_id: impl Display) -> Result<models::InternalGroupPermissions> {
let path = format!("/permissions/internal/groups/{}", seg(group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get the current user’s internal permissions by group
///
/// `GET /permissions/internal/groups`
///
/// Calculates the authenticated user’s group-internal permissions from active memberships, role assignments and inheritance through the group hierarchy. Returns an unpaginated map keyed by target group ID, or \[\] when there are no calculated groups. Values are grouped by active module, including false/0 defaults for registered keys without grants. This is an internal-permission calculation, not a list of visible groups or a complete authorization decision: global grants and object policies are separate. No permission-administration grant is required. The legacy +create posts flag is derived only by the single-group endpoint, not here.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-internal-groups");
/// let result = client.permissions().internal().groups().list()?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<serde_json::Value> {
let path = "/permissions/internal/groups".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.permissions().internal().groups().auths()`
#[derive(Clone, Copy)]
pub struct PermissionsInternalGroupsAuthsResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsInternalGroupsAuthsResource<'a> {
/// List Persons with a Group-Internal Permission
///
/// `GET /permissions/internal/groups/{groupId}/auths/{authId}/persons`
///
/// Lists non-archived persons with one effective group-internal permission in the target group, combining direct and inherited grants and excluding revoked contributions. Requires administer persons in churchcore. The group must exist, but no additional group/person visibility check is performed. For selectable permissions data_id is required: a configured ID yields one selection, while -1 yields one selection for each currently configured value in ascending order, possibly none. Unlike the global endpoint, -1 does not mean only persons with unrestricted grants. Maximum permissions match every requested level up to the effective maximum. For boolean permissions omit data_id; the single selection then has dataId=null. Person IDs are sorted numerically. No pagination or include=origins option is implemented here. Unknown groups and unknown, inactive or global authId values return 404; invalid selection combinations return 400.
///
/// Use [`Self::get_persons_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-internal-groups-groupId-auths-authId-persons");
/// let person = client.permissions().internal().groups().auths().get_persons(42, 125)?;
/// println!("{}", person.auth_id);
/// # Ok(())
/// # }
/// ```
pub fn get_persons(&self, group_id: impl Display, auth_id: impl Display) -> Result<models::PermissionPersons> {
self.get_persons_with(group_id, auth_id, &Default::default())
}
/// List Persons with a Group-Internal Permission
///
/// Like [`Self::get_persons`], with query parameters.
///
/// `GET /permissions/internal/groups/{groupId}/auths/{authId}/persons`
///
/// Lists non-archived persons with one effective group-internal permission in the target group, combining direct and inherited grants and excluding revoked contributions. Requires administer persons in churchcore. The group must exist, but no additional group/person visibility check is performed. For selectable permissions data_id is required: a configured ID yields one selection, while -1 yields one selection for each currently configured value in ascending order, possibly none. Unlike the global endpoint, -1 does not mean only persons with unrestricted grants. Maximum permissions match every requested level up to the effective maximum. For boolean permissions omit data_id; the single selection then has dataId=null. Person IDs are sorted numerically. No pagination or include=origins option is implemented here. Unknown groups and unknown, inactive or global authId values return 404; invalid selection combinations return 400.
pub fn get_persons_with(&self, group_id: impl Display, auth_id: impl Display, query: &GetPermissionsInternalGroupsGroupIdAuthsAuthIdPersonsQuery) -> Result<models::PermissionPersons> {
let path = format!("/permissions/internal/groups/{}/auths/{}/persons", seg(group_id), seg(auth_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.permissions().internal().persons()`
#[derive(Clone, Copy)]
pub struct PermissionsInternalPersonsResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsInternalPersonsResource<'a> {
/// Get the current user’s internal permissions toward a person
///
/// `GET /permissions/internal/persons/{personId}`
///
/// Calculates what the authenticated user is granted through group-internal permissions toward the target person. It does not return that person’s own grants. The target groups come from the person’s memberships in non-archived groups, currently including requested, waiting and to-delete memberships. The caller’s effective internal grants across those groups are combined by maximum value for person-related keys. Missing flags are false and missing levels are 0; unrestricted levels use 99999. No person-visibility or existence check is performed, so an unknown person ID returns default values rather than 404. Global grants and additional person policies are not included. +edit persons is a deprecated boolean derived from the modern person-field level. Service-module keys are absent when that module is inactive.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-internal-persons-id");
/// let person = client.permissions().internal().persons().get(42)?;
/// println!("{:?}", person);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display) -> Result<models::InternalPersonPermissions> {
let path = format!("/permissions/internal/persons/{}", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.permissions().origins()`
#[derive(Clone, Copy)]
pub struct PermissionsOriginsResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsOriginsResource<'a> {
pub fn global(&self) -> PermissionsOriginsGlobalResource<'a> {
PermissionsOriginsGlobalResource { client: self.client }
}
pub fn internal(&self) -> PermissionsOriginsInternalResource<'a> {
PermissionsOriginsInternalResource { client: self.client }
}
}
/// `client.permissions().origins().global_()`
#[derive(Clone, Copy)]
pub struct PermissionsOriginsGlobalResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsOriginsGlobalResource<'a> {
pub fn persons(&self) -> PermissionsOriginsGlobalPersonsResource<'a> {
PermissionsOriginsGlobalPersonsResource { client: self.client }
}
}
/// `client.permissions().origins().global_().persons()`
#[derive(Clone, Copy)]
pub struct PermissionsOriginsGlobalPersonsResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsOriginsGlobalPersonsResource<'a> {
/// Explain Global Permissions of a Person
///
/// `GET /permissions/origins/global/persons/{personId}`
///
/// Explains global permission sources for the person specified in the path. Requires administer persons in churchcore even for the caller’s own ID. Sources include logged-in defaults, public-user rights, person status, direct person assignments, direct group/group-type roles and super-admin status. Only active memberships in groups that grant permissions contribute; archived persons have no normal origin data. No person-visibility or existence check is performed: unknown or archived IDs return the requested personId with an empty permissions array rather than 404. Entries follow active permission-definition order; each origin carries its own contribution and the entry carries the combined value. Global maximum-level values are integers here, unlike the arrays used by /permissions/global. No pagination is applied.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-origins-global-persons-personId");
/// let person = client.permissions().origins().global().persons().get(42)?;
/// println!("{}", person.person_id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display) -> Result<models::GetPermissionsOriginsGlobalPersonsPersonIdData> {
let path = format!("/permissions/origins/global/persons/{}", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.permissions().origins().internal()`
#[derive(Clone, Copy)]
pub struct PermissionsOriginsInternalResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsOriginsInternalResource<'a> {
pub fn persons(&self) -> PermissionsOriginsInternalPersonsResource<'a> {
PermissionsOriginsInternalPersonsResource { client: self.client }
}
}
/// `client.permissions().origins().internal().persons()`
#[derive(Clone, Copy)]
pub struct PermissionsOriginsInternalPersonsResource<'a> {
client: &'a Client,
}
impl<'a> PermissionsOriginsInternalPersonsResource<'a> {
/// Explain Group Internal Permissions of a Person
///
/// `GET /permissions/origins/internal/persons/{personId}`
///
/// Explains the specified person’s group-internal (+) permission origins, grouped by target group. Requires administer persons in churchcore; no additional person/group visibility check is performed. Origins are group-role and group-type-role assignments from active memberships. inherited=true identifies a grant reaching the target through a superior group; origin.groupId is the donor group, while the outer groupId is the target. revokedByGroupRoleId marks a contribution canceled by that group role. Entries with only revoked contributions are still returned with false, 0 or \[\] as effectiveValue, so presence alone does not mean access is granted. Omit group_ids to inspect all targets; an explicit empty array selects none. Unknown target IDs and targets without recorded contributions are omitted. Unknown or archived person IDs return the requested personId and an empty groups array. Permissions follow definition order; no explicit group ordering or pagination is applied.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-permissions-origins-internal-persons-personId");
/// let person = client.permissions().origins().internal().persons().get(42)?;
/// println!("{}", person.person_id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display) -> Result<models::GetPermissionsOriginsInternalPersonsPersonIdData> {
self.get_with(person_id, &Default::default())
}
/// Explain Group Internal Permissions of a Person
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /permissions/origins/internal/persons/{personId}`
///
/// Explains the specified person’s group-internal (+) permission origins, grouped by target group. Requires administer persons in churchcore; no additional person/group visibility check is performed. Origins are group-role and group-type-role assignments from active memberships. inherited=true identifies a grant reaching the target through a superior group; origin.groupId is the donor group, while the outer groupId is the target. revokedByGroupRoleId marks a contribution canceled by that group role. Entries with only revoked contributions are still returned with false, 0 or \[\] as effectiveValue, so presence alone does not mean access is granted. Omit group_ids to inspect all targets; an explicit empty array selects none. Unknown target IDs and targets without recorded contributions are omitted. Unknown or archived person IDs return the requested personId and an empty groups array. Permissions follow definition order; no explicit group ordering or pagination is applied.
pub fn get_with(&self, person_id: impl Display, query: &GetPermissionsOriginsInternalPersonsPersonIdQuery) -> Result<models::GetPermissionsOriginsInternalPersonsPersonIdData> {
let path = format!("/permissions/origins/internal/persons/{}", seg(person_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.person()`
#[derive(Clone, Copy)]
pub struct PersonResource<'a> {
client: &'a Client,
}
impl<'a> PersonResource<'a> {
pub fn comment_viewers(&self) -> PersonCommentViewersResource<'a> {
PersonCommentViewersResource { client: self.client }
}
pub fn grow_paths(&self) -> PersonGrowPathsResource<'a> {
PersonGrowPathsResource { client: self.client }
}
pub fn relationship_types(&self) -> PersonRelationshipTypesResource<'a> {
PersonRelationshipTypesResource { client: self.client }
}
pub fn sexes(&self) -> PersonSexesResource<'a> {
PersonSexesResource { client: self.client }
}
/// Get People & Groups reference catalogs
///
/// `GET /person/masterdata`
///
/// Returns complete reference catalogs for People & Groups, including membership roles, group and person classifications, campuses, relationship types and meeting feedback templates. These are reference definitions, not person records or group memberships. Roles are ordered by type and `sortKey`; campuses by `sortKey`.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-person-masterdata");
/// let master_data = client.person().get_master_data()?;
/// println!("{:?}", master_data);
/// # Ok(())
/// # }
/// ```
pub fn get_master_data(&self) -> Result<models::PersonMasterData> {
let path = "/person/masterdata".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.person().comment_viewers()`
#[derive(Clone, Copy)]
pub struct PersonCommentViewersResource<'a> {
client: &'a Client,
}
impl<'a> PersonCommentViewersResource<'a> {
/// Create a person-comment visibility category
///
/// `POST /person/commentviewers`
///
/// Creates a visibility category for person comments and person-linked notes. Requires edit masterdata in churchdb. name is trimmed and must contain 1–50 characters; duplicate names are allowed. sortKey defaults to 0. The returned category has a generated ID and a translated display name. Creating a category does not assign view comments permissions to any person or role.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-person-commentviewers");
/// let body = models::CommentViewerCreate {
/// name: "Pastoral team".into(),
/// ..Default::default()
/// };
/// let result = client.person().comment_viewers().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::CommentViewerCreate) -> Result<models::CommentViewer> {
let path = "/person/commentviewers".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a person-comment visibility category
///
/// `DELETE /person/commentviewers/{id}`
///
/// Deletes an unused visibility category. Requires edit masterdata in churchdb. Legacy person comments and note links referencing this category block deletion with 409. Successful deletion also removes explicit churchdb view comments assignments for this category and invalidates the permission cache. dry_run=true only checks references and returns 409 with the deletion report even when deletion would be allowed; it never returns 204. A missing category is not explicitly loaded before deletion, so a real delete can return 204 without having removed a row.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.person().comment_viewers().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete a person-comment visibility category
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /person/commentviewers/{id}`
///
/// Deletes an unused visibility category. Requires edit masterdata in churchdb. Legacy person comments and note links referencing this category block deletion with 409. Successful deletion also removes explicit churchdb view comments assignments for this category and invalidates the permission cache. dry_run=true only checks references and returns 409 with the deletion report even when deletion would be allowed; it never returns 204. A missing category is not explicitly loaded before deletion, so a real delete can return 204 without having removed a row.
pub fn delete_with(&self, id: impl Display, query: &DeletePersonCommentviewersIdQuery) -> Result<()> {
let path = format!("/person/commentviewers/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a person-comment visibility category
///
/// `GET /person/commentviewers/{id}`
///
/// Returns one category used to classify the visibility of person comments and person-linked notes. Requires authentication; no master-data-edit or view-comments grant for this category is checked. Reading this catalog entry does not authorize reading comments assigned to it. Includes its stored name, translated display name and sort key. Unknown IDs return 404.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-person-commentviewers-id");
/// let comment_viewer = client.person().comment_viewers().get(1)?;
/// println!("{}", comment_viewer.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::CommentViewer> {
let path = format!("/person/commentviewers/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List person-comment visibility categories
///
/// `GET /person/commentviewers`
///
/// Lists all configured visibility categories for person comments and person-linked notes. A category is not a user group: assign churchdb view comments for its ID to control who may see matching content, subject to the content endpoint’s additional rules. Requires authentication, but no master-data-edit or per-category view-comments permission is checked here. The catalog is unpaginated and includes categories the caller cannot use to read content. Results are sorted by sortKey, then the stored name, both ascending.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-person-commentviewers");
/// for comment_viewer in client.person().comment_viewers().list()? {
/// println!("{}", comment_viewer.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::CommentViewer>> {
let path = "/person/commentviewers".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a person-comment visibility category
///
/// `PUT /person/commentviewers/{id}`
///
/// Updates a category’s name and optionally its sort key. Requires edit masterdata in churchdb. The ID is taken from the path; no duplicate ID is required in the body. name is required, trimmed to 1–50 characters, and need not be unique. Unlike create, an omitted sortKey preserves the existing value. Explicit null currently passes validation but fails the integer setter, so omit the field to preserve it. Existing comment/note assignments and permission selections keep referencing the same category ID. Unknown IDs return 404.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-person-commentviewers-id");
/// let body = models::CommentViewerUpdate {
/// name: "Pastoral team".into(),
/// ..Default::default()
/// };
/// let result = client.person().comment_viewers().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::CommentViewerUpdate) -> Result<models::CommentViewer> {
let path = format!("/person/commentviewers/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.person().grow_paths()`
#[derive(Clone, Copy)]
pub struct PersonGrowPathsResource<'a> {
client: &'a Client,
}
impl<'a> PersonGrowPathsResource<'a> {
/// Create a growth-path stage
///
/// `POST /person/growpaths`
///
/// Creates a stage in the growth-path catalog. Requires edit masterdata in churchdb. name is trimmed to 1–100 characters and need not be unique. color must be one of the accepted CTColor keys. sortKey is optional and defaults to 0; it controls both display ordering and precedence when deriving a person’s stage. The new stage is not automatically assigned to a role or person. Returns 201 with the generated ID, translated name and metadata.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-person-growpaths");
/// let body = models::GrowPathCreate {
/// color: serde_json::json!("accent"),
/// name: "New Believer".into(),
/// ..Default::default()
/// };
/// let result = client.person().grow_paths().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::GrowPathCreate) -> Result<models::GrowPath> {
let path = "/person/growpaths".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a growth-path stage
///
/// `DELETE /person/growpaths/{id}`
///
/// Deletes an unused growth-path stage. Requires edit masterdata in churchdb. References from group-type roles and concrete group roles block deletion with 409. Use dryRun=true to inspect deletion dependencies without deleting anything; the report also uses 409 when there are no blockers. The snake_case dry_run parameter used by other endpoints is not the flag read here. The stage is not loaded before deletion, so an unknown ID can return 204 without removing a row.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.person().grow_paths().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete a growth-path stage
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /person/growpaths/{id}`
///
/// Deletes an unused growth-path stage. Requires edit masterdata in churchdb. References from group-type roles and concrete group roles block deletion with 409. Use dryRun=true to inspect deletion dependencies without deleting anything; the report also uses 409 when there are no blockers. The snake_case dry_run parameter used by other endpoints is not the flag read here. The stage is not loaded before deletion, so an unknown ID can return 204 without removing a row.
pub fn delete_with(&self, id: impl Display, query: &DeletePersonGrowpathsIdQuery) -> Result<()> {
let path = format!("/person/growpaths/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a growth-path stage
///
/// `GET /person/growpaths/{id}`
///
/// Returns one configured growth-path stage, including translated name, display color, ordering/priority and metadata. Requires view in churchdb. The ID identifies a stage referenced by group roles and person growPathId values; this is not the history or progression of a particular person. Unknown IDs return 404.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-person-growpaths-id");
/// let grow_path = client.person().grow_paths().get(1)?;
/// println!("{}", grow_path.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::GrowPath> {
let path = format!("/person/growpaths/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List growth-path stages
///
/// `GET /person/growpaths`
///
/// Lists the configured growth-path stages, ordered by sortKey and stored name ascending. Requires view in churchdb. Stages are assigned to group-type roles or concrete group roles; ChurchTools derives a person’s stage from active memberships in active or finished groups, using the highest matching stage sortKey. A concrete group-role stage overrides the group-type-role stage for that membership. This endpoint returns the complete unpaginated stage catalog, not people or their progress history. Each stage includes translated display text, color and creation/modification metadata.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-person-growpaths");
/// for grow_path in client.person().grow_paths().list()? {
/// println!("{}", grow_path.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::GrowPath>> {
let path = "/person/growpaths".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a growth-path stage
///
/// `PUT /person/growpaths/{id}`
///
/// Updates a stage’s name, color and ordering/priority. Requires edit masterdata in churchdb. ID comes from the path; name and color are required. sortKey is optional but defaults to 0 on every update, so send its current value to retain it. This differs from comment-viewer updates, which preserve an omitted sort key. sortKey affects both display order and which stage wins when calculating a person’s growth path. This handler only persists the stage; it does not trigger recalculation of all already stored person growPathId values. Equal priorities have no explicit tie-breaker in person calculation. Unknown IDs return 404.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-person-growpaths-id");
/// let body = models::GrowPathUpdate {
/// color: serde_json::json!("accent"),
/// name: "New Believer".into(),
/// ..Default::default()
/// };
/// let result = client.person().grow_paths().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::GrowPathUpdate) -> Result<models::GrowPath> {
let path = format!("/person/growpaths/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.person().relationship_types()`
#[derive(Clone, Copy)]
pub struct PersonRelationshipTypesResource<'a> {
client: &'a Client,
}
impl<'a> PersonRelationshipTypesResource<'a> {
/// Create a person relationship type
///
/// `POST /person/relationshiptypes`
///
/// Creates a relationship-type catalog definition. Requires "edit masterdata" permission in `churchdb`.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-person-relationshiptypes");
/// let body = models::RelationshipTypeCreate {
/// degree_name_a: "Parent".into(),
/// degree_name_b: "Child".into(),
/// security_level_id: 1,
/// ..Default::default()
/// };
/// let result = client.person().relationship_types().create(&body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::RelationshipTypeCreate) -> Result<models::RelationshipType> {
let path = "/person/relationshiptypes".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a relationship type and its person relationships
///
/// `DELETE /person/relationshiptypes/{id}`
///
/// Deletes the relationship-type definition and every stored person-to-person relationship referencing it. Requires "edit masterdata" permission in `churchdb`. Types with the built-in `nodelete` flag cannot be deleted.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.person().relationship_types().delete(4)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete a relationship type and its person relationships
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /person/relationshiptypes/{id}`
///
/// Deletes the relationship-type definition and every stored person-to-person relationship referencing it. Requires "edit masterdata" permission in `churchdb`. Types with the built-in `nodelete` flag cannot be deleted.
pub fn delete_with(&self, id: impl Display, query: &DeletePersonRelationshiptypesIdQuery) -> Result<()> {
let path = format!("/person/relationshiptypes/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a person relationship type
///
/// `GET /person/relationshiptypes/{id}`
///
/// Returns one relationship-type catalog definition, not a relationship between two persons.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-person-relationshiptypes-id");
/// let relationship_type = client.person().relationship_types().get(4)?;
/// println!("{:?}", relationship_type.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::RelationshipType> {
let path = format!("/person/relationshiptypes/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List person relationship types
///
/// `GET /person/relationshiptypes`
///
/// Lists relationship-type definitions, ordered by `sortKey` and stored name. This is a catalog, not the relationships between individual persons.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-person-relationshiptypes");
/// for relationship_type in client.person().relationship_types().list()? {
/// println!("{:?}", relationship_type.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::RelationshipType>> {
let path = "/person/relationshiptypes".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a person relationship type
///
/// `PUT /person/relationshiptypes/{id}`
///
/// Replaces the editable fields of an existing relationship-type definition. Requires "edit masterdata" permission in `churchdb`. Existing person-to-person relationships retain their IDs and use the updated definition.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-person-relationshiptypes-id");
/// let body = models::RelationshipTypeUpdate {
/// degree_name_a: "Parent".into(),
/// degree_name_b: "Child".into(),
/// security_level_id: 1,
/// ..Default::default()
/// };
/// let result = client.person().relationship_types().update(4, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::RelationshipTypeUpdate) -> Result<models::RelationshipType> {
let path = format!("/person/relationshiptypes/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.person().sexes()`
#[derive(Clone, Copy)]
pub struct PersonSexesResource<'a> {
client: &'a Client,
}
impl<'a> PersonSexesResource<'a> {
/// Create sex
///
/// `POST /person/sexes`
///
/// Creates a sex catalog entry, not a person. Requires edit masterdata permission for Persons (churchdb). Text is trimmed; omitted salutations are null and sortKey defaults to 0. Name and salutation values may be translation keys or literal text. Creation is transactional.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-person-sexes");
/// let body = models::SexCreate {
/// name: "sex.other".into(),
/// ..Default::default()
/// };
/// let result = client.person().sexes().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::SexCreate) -> Result<models::Sex> {
let path = "/person/sexes".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete sex
///
/// `DELETE /person/sexes/{id}`
///
/// Deletes an unused sex catalog entry. Requires edit masterdata permission for Persons (churchdb). IDs 1 and 2 return 403 even for dryRun. Person references block deletion with 409. dryRun=true always returns a 409 deletion report for otherwise eligible IDs, including when deletion would be allowed. A missing unused ID is a successful no-op with 204.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.person().sexes().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete sex
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /person/sexes/{id}`
///
/// Deletes an unused sex catalog entry. Requires edit masterdata permission for Persons (churchdb). IDs 1 and 2 return 403 even for dryRun. Person references block deletion with 409. dryRun=true always returns a 409 deletion report for otherwise eligible IDs, including when deletion would be allowed. A missing unused ID is a successful no-op with 204.
pub fn delete_with(&self, id: impl Display, query: &DeletePersonSexesIdQuery) -> Result<()> {
let path = format!("/person/sexes/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get sex
///
/// `GET /person/sexes/{id}`
///
/// Returns one sex catalog entry with raw and localized labels and salutations. Requires view permission for Persons (churchdb).
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-person-sexes-id");
/// let sex = client.person().sexes().get(1)?;
/// println!("{}", sex.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::Sex> {
let path = format!("/person/sexes/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all sexes
///
/// `GET /person/sexes`
///
/// Lists the configured sex catalog used by person records and salutations. Requires view permission for Persons (churchdb). Ordered by sortKey and stored name ascending; localized display text can have a different order. The complete catalog is returned without pagination.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-person-sexes");
/// for sex in client.person().sexes().list()? {
/// println!("{}", sex.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Sex>> {
let path = "/person/sexes".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a sex entry
///
/// `PUT /person/sexes/{id}`
///
/// Replaces the writable values of a sex catalog entry. Requires edit masterdata permission for Persons (churchdb). name is required; omitted sortKey is reset to 0 and omitted salutations are cleared to null. IDs 1 and 2 are protected against deletion but can be updated here. The ID is taken from the URL and is not required in the body. The update is transactional.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-person-sexes-id");
/// let body = models::SexUpdate {
/// name: "sex.other".into(),
/// ..Default::default()
/// };
/// let result = client.person().sexes().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::SexUpdate) -> Result<models::Sex> {
let path = format!("/person/sexes/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.persons()`
#[derive(Clone, Copy)]
pub struct PersonsResource<'a> {
client: &'a Client,
}
impl<'a> PersonsResource<'a> {
pub fn absences(&self) -> PersonsAbsencesResource<'a> {
PersonsAbsencesResource { client: self.client }
}
pub fn devices(&self) -> PersonsDevicesResource<'a> {
PersonsDevicesResource { client: self.client }
}
pub fn events(&self) -> PersonsEventsResource<'a> {
PersonsEventsResource { client: self.client }
}
pub fn exchange_requests(&self) -> PersonsExchangeRequestsResource<'a> {
PersonsExchangeRequestsResource { client: self.client }
}
pub fn external_logins(&self) -> PersonsExternalLoginsResource<'a> {
PersonsExternalLoginsResource { client: self.client }
}
pub fn followups(&self) -> PersonsFollowupsResource<'a> {
PersonsFollowupsResource { client: self.client }
}
pub fn merge(&self) -> PersonsMergeResource<'a> {
PersonsMergeResource { client: self.client }
}
pub fn relationships(&self) -> PersonsRelationshipsResource<'a> {
PersonsRelationshipsResource { client: self.client }
}
pub fn service_requests(&self) -> PersonsServiceRequestsResource<'a> {
PersonsServiceRequestsResource { client: self.client }
}
pub fn settings(&self) -> PersonsSettingsResource<'a> {
PersonsSettingsResource { client: self.client }
}
/// `POST /persons/{personId}/archive`
///
/// archives or undos an archive of a person
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostPersonsPersonIdArchiveBody {
/// archived: Some(true),
/// ..Default::default()
/// };
/// client.persons().archive(42, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn archive(&self, person_id: impl Display, body: &models::PostPersonsPersonIdArchiveBody) -> Result<()> {
let path = format!("/persons/{}/archive", seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Create new person
///
/// `POST /persons`
///
/// Creates a person using only fields the current user may write. Before calling this endpoint, retrieve valid `statusId`, `campusId`, and `departmentIds` values from `GET /person/masterdata`. Read `GET /config` to determine whether `privacy_policy_fields_mandatory` is enabled. If it is enabled, provide all three privacy agreement fields. `privacyPolicyAgreementTypeId` describes how the agreement was obtained, while `privacyPolicyAgreementWhoId` describes who gave it; these are independent facts and must not be inferred from each other. The `without_privacy_policy_agreement` parameter is only effective when `privacy_policy_fields_mandatory_api` is disabled and must not be used without first verifying that setting. If a duplicate person is found, repeat the request with `force` only after intentionally deciding to create the duplicate.
///
/// Use [`Self::create_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-persons");
/// let body = models::PostPersonsBody {
/// department_ids: vec![42],
/// ..Default::default()
/// };
/// let result = client.persons().create(&body)?;
/// println!("{:?}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::PostPersonsBody) -> Result<models::Person> {
self.create_with(&Default::default(), body)
}
/// Create new person
///
/// Like [`Self::create`], with query parameters.
///
/// `POST /persons`
///
/// Creates a person using only fields the current user may write. Before calling this endpoint, retrieve valid `statusId`, `campusId`, and `departmentIds` values from `GET /person/masterdata`. Read `GET /config` to determine whether `privacy_policy_fields_mandatory` is enabled. If it is enabled, provide all three privacy agreement fields. `privacyPolicyAgreementTypeId` describes how the agreement was obtained, while `privacyPolicyAgreementWhoId` describes who gave it; these are independent facts and must not be inferred from each other. The `without_privacy_policy_agreement` parameter is only effective when `privacy_policy_fields_mandatory_api` is disabled and must not be used without first verifying that setting. If a duplicate person is found, repeat the request with `force` only after intentionally deciding to create the duplicate.
pub fn create_with(&self, query: &PostPersonsQuery, body: &models::PostPersonsBody) -> Result<models::Person> {
let path = "/persons".to_owned();
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete person
///
/// `DELETE /persons/{personId}`
///
/// Delete the Person
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().delete(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display) -> Result<()> {
let path = format!("/persons/{}", seg(person_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Revoke a person's confidentiality agreement
///
/// `DELETE /persons/{personId}/confidentialityagreement`
///
/// Clears the confidentiality acceptance date. Requires write access for Persons (churchdb); being the selected person alone is insufficient. Simulation is rejected. The policy checks module-level write access without an additional person-visibility check. Already absent acceptance is a successful no-op. This is separate from privacy-consent revocation and takes no request body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().delete_confidentiality_agreement(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_confidentiality_agreement(&self, person_id: impl Display) -> Result<()> {
let path = format!("/persons/{}/confidentialityagreement", seg(person_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Revoke the current person’s login token
///
/// `DELETE /persons/{personId}/logintoken`
///
/// Deletes the current person’s persistent login token. Only the current person may revoke their own token. A missing token is treated as success. Ordinary user simulation is forbidden; support-user simulation is exempt. This does not invalidate existing sessions or separate one-time login strings. A subsequent GET creates a new token.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().delete_login_token(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_login_token(&self, person_id: impl Display) -> Result<()> {
let path = format!("/persons/{}/logintoken", seg(person_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Revoke privacy consent
///
/// `DELETE /persons/{personId}/privacypolicy`
///
/// Clears the person’s consent timestamp, consent type and consent-giver category, and then notifies the configured administrator by email when an address is available. Requires an enabled consent banner and either the person themselves, a super administrator, or the parent of a person not known to be at least 16 through relationship type 1. Simulation is rejected. Revocation is not idempotent: an existing person without prior consent raises an application error instead of returning 204. Notification happens after the data change, so a later failure does not imply that consent was retained.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().delete_privacy_policy(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_privacy_policy(&self, person_id: impl Display) -> Result<()> {
let path = format!("/persons/{}/privacypolicy", seg(person_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// `POST /persons/export`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().export()?;
/// # Ok(())
/// # }
/// ```
pub fn export(&self) -> Result<()> {
let path = "/persons/export".to_owned();
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Filter persons with probes
///
/// `POST /persons/filter`
///
/// Evaluates a logical expression of probes against all persons the current user may view. Probe evaluation honors person security levels, and the matching persons are returned as a paginated collection.
///
/// Use [`Self::filter_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = serde_json::json!({
/// "data": {},
/// "probe": "probe-person-field"
/// });
/// for person in client.persons().filter(&body)? {
/// println!("{:?}", person.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn filter(&self, body: &serde_json::Value) -> Result<Vec<models::Person>> {
self.filter_with(&Default::default(), body)
}
/// Filter persons with probes
///
/// Like [`Self::filter`], with query parameters.
///
/// `POST /persons/filter`
///
/// Evaluates a logical expression of probes against all persons the current user may view. Probe evaluation honors person security levels, and the matching persons are returned as a paginated collection.
pub fn filter_with(&self, query: &PostPersonsFilterQuery, body: &serde_json::Value) -> Result<Vec<models::Person>> {
let path = "/persons/filter".to_owned();
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get a person by ID or GUID
///
/// `GET /persons/{personId}`
///
/// Each person as a unique numeric ID in ChurchTools. This ID is used all over in ChurchTools and in the API.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id");
/// let person = client.persons().get(42)?;
/// println!("{:?}", person.title);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display) -> Result<models::Person> {
let path = format!("/persons/{}", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Generate a personal data sheet PDF
///
/// `GET /persons/{personId}/information`
///
/// Generates the complete configured data sheet for the person and returns a PDF download URL. Requires super-administrator access, even when exporting your own data. Despite using GET, every successful call generates and stores a file and logs the export; this is not a read-only preview. The file is associated with the datasheet domain and scheduled for deletion after one day. The API response is JSON, not PDF bytes. message is localized display text. Unknown persons return 404; generation or storage failures may return 500.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-information");
/// let information = client.persons().get_information(42)?;
/// println!("{}", information.pdf_link);
/// # Ok(())
/// # }
/// ```
pub fn get_information(&self, person_id: impl Display) -> Result<models::PersonInformationExport> {
let path = format!("/persons/{}/information", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Create a one-time login string for the current person
///
/// `GET /persons/{personId}/loginstring`
///
/// Creates a new one-time login credential valid for 14 days. Only the current person may request their own credential. Each GET creates and stores a fresh credential; treat the response as a secret. Use it as the loginstr parameter of a ChurchTools login link. Simulation creates a credential carrying the simulating user context. The legacy response has top-level loginString and personId fields, without a data envelope.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-loginstring");
/// let login_string = client.persons().get_login_string("abc123")?;
/// println!("{}", login_string.login_string);
/// # Ok(())
/// # }
/// ```
pub fn get_login_string(&self, person_id: impl Display) -> Result<models::GetPersonsIdLoginstringResponse> {
let path = format!("/persons/{}/loginstring", seg(person_id));
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
/// Get or create the current person’s login token
///
/// `GET /persons/{personId}/logintoken`
///
/// Returns the current person’s persistent login credential, creating and storing one if absent. Only the current person may request their own token. The same token is returned on subsequent calls until revoked; treat it as a secret. It has no expiry field. Ordinary user simulation is forbidden; support-user simulation is exempt. This GET can change stored data.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-logintoken");
/// let result = client.persons().get_login_token(42)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_login_token(&self, person_id: impl Display) -> Result<String> {
let path = format!("/persons/{}/logintoken", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Returns the post statistics for a person
///
/// `GET /persons/{personId}/poststatistics`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-poststatistics");
/// let post_statistic = client.persons().get_post_statistics("abc123")?;
/// println!("{}", post_statistic.count_banned);
/// # Ok(())
/// # }
/// ```
pub fn get_post_statistics(&self, person_id: impl Display) -> Result<models::PersonPostStatistics> {
let path = format!("/persons/{}/poststatistics", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get privacy-consent information
///
/// `GET /persons/{personId}/privacypolicy`
///
/// Returns consent details and parent/child relationship information for the selected person. Simulation is rejected. Access is allowed to super administrators, the person themselves unless they are known to be younger than 16, and a parent linked through relationship type 1 for a person who is not known to be at least 16. An unknown birthday is treated differently by the self-read and acceptance checks. The response supplies suggested typeId/whoId and display flags; it does not grant permission to submit consent.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-privacypolicy");
/// let privacy_policy = client.persons().get_privacy_policy(42)?;
/// println!("{}", privacy_policy.minimum_age);
/// # Ok(())
/// # }
/// ```
pub fn get_privacy_policy(&self, person_id: impl Display) -> Result<models::PersonPrivacyPolicy> {
let path = format!("/persons/{}/privacypolicy", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Invite Person to ChurchTools
///
/// `POST /persons/{personId}/invite`
///
/// Sends a ChurchTools invitation email to the person’s stored email address. Requires the global churchcore permission invite persons or the group-internal churchdb +invite person permission for this person. Archived people cannot be invited. The call forces sending even after an earlier invitation or acceptance. With local login enabled, the email links to setting a password; with local login disabled, it links to the login page. No request body is consumed. A 204 response indicates that invitation processing completed, not confirmed email delivery.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().invite(42)?;
/// # Ok(())
/// # }
/// ```
pub fn invite(&self, person_id: impl Display) -> Result<()> {
let path = format!("/persons/{}/invite", seg(person_id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Get all persons
///
/// `GET /persons`
///
/// This endpoint gives you all the people you are allowed to see. Each person object holds only those fields you may see. You will get at least an empty array even if you cannot see any person. The results are sorted by lastname, firstname.
///
/// We distinguish between `date` and `date-time` fields. `date` is a ISO representation like `YYYY-MM-DD`. On the other hand, for `date-time` we return and accept a W3C Zulu date string. Example `1994-11-05T08:15:30Z`
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons");
/// for person in client.persons().list()? {
/// println!("{:?}", person.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Person>> {
self.list_with(&Default::default())
}
/// Get all persons
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /persons`
///
/// This endpoint gives you all the people you are allowed to see. Each person object holds only those fields you may see. You will get at least an empty array even if you cannot see any person. The results are sorted by lastname, firstname.
///
/// We distinguish between `date` and `date-time` fields. `date` is a ISO representation like `YYYY-MM-DD`. On the other hand, for `date-time` we return and accept a W3C Zulu date string. Example `1994-11-05T08:15:30Z`
pub fn list_with(&self, query: &GetPersonsQuery) -> Result<Vec<models::Person>> {
let path = "/persons".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all persons
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetPersonsQuery) -> Items<models::Person> {
let path = "/persons".to_owned();
self.client.items(&path, query.to_query())
}
/// Fetch Birthdays
///
/// `GET /persons/birthdays`
///
/// This endpoint returns birthdays within a specific time interval. The returned objects are ordered by MONTH-DAY, where the first birthday in the list is the one next from the start date.
/// The API also returns the `age` of the birthday. That age is calculated based on the date interval. That means, it is not the current age and also not the next birthday, but the age which the person had/will have at the end of the given date interval.
/// There are two ways to utilize this endpoint:
/// 1. With a fixed date interval (`start_date`, `end_date`). This
/// interval must not be larger than one year.
/// 2. With a `start_date` and a `direction` field. This combination also
/// accepts a `page` and `limit` parameter (both with suitable defaults)
/// to paginate through the results.
///
/// Use [`Self::list_birthdays_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-birthdays");
/// for birthday in client.persons().list_birthdays()? {
/// println!("{:?}", birthday.deprecated);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_birthdays(&self) -> Result<Vec<models::GetPersonsBirthdaysDataItem>> {
self.list_birthdays_with(&Default::default())
}
/// Fetch Birthdays
///
/// Like [`Self::list_birthdays`], with query parameters.
///
/// `GET /persons/birthdays`
///
/// This endpoint returns birthdays within a specific time interval. The returned objects are ordered by MONTH-DAY, where the first birthday in the list is the one next from the start date.
/// The API also returns the `age` of the birthday. That age is calculated based on the date interval. That means, it is not the current age and also not the next birthday, but the age which the person had/will have at the end of the given date interval.
/// There are two ways to utilize this endpoint:
/// 1. With a fixed date interval (`start_date`, `end_date`). This
/// interval must not be larger than one year.
/// 2. With a `start_date` and a `direction` field. This combination also
/// accepts a `page` and `limit` parameter (both with suitable defaults)
/// to paginate through the results.
pub fn list_birthdays_with(&self, query: &GetPersonsBirthdaysQuery) -> Result<Vec<models::GetPersonsBirthdaysDataItem>> {
let path = "/persons/birthdays".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Fetch Birthdays
///
/// Like [`Self::list_birthdays_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_birthdays_iter(&self, query: &GetPersonsBirthdaysQuery) -> Items<models::GetPersonsBirthdaysDataItem> {
let path = "/persons/birthdays".to_owned();
self.client.items(&path, query.to_query())
}
/// get potential duplicates of persons
///
/// `GET /persons/duplicates`
///
/// **Caution:** This API is published as Beta and subject to be changed. It is published such that customers can play evaluate it with production data.
///
/// Provide a list of potential duplicate person records. You can suppress some duplicates
///
/// The other parameters are used to filter duplicates.
///
/// Returns an array of duplicates
///
/// * `p1` - properties of Person 1
/// * `p2` - properties of Person 2
///
/// Use [`Self::list_duplicates_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-duplicates");
/// for duplicate in client.persons().list_duplicates()? {
/// println!("{:?}", duplicate.relationship_type_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_duplicates(&self) -> Result<Vec<models::GetPersonsDuplicatesDataItem>> {
self.list_duplicates_with(&Default::default())
}
/// get potential duplicates of persons
///
/// Like [`Self::list_duplicates`], with query parameters.
///
/// `GET /persons/duplicates`
///
/// **Caution:** This API is published as Beta and subject to be changed. It is published such that customers can play evaluate it with production data.
///
/// Provide a list of potential duplicate person records. You can suppress some duplicates
///
/// The other parameters are used to filter duplicates.
///
/// Returns an array of duplicates
///
/// * `p1` - properties of Person 1
/// * `p2` - properties of Person 2
pub fn list_duplicates_with(&self, query: &GetPersonsDuplicatesQuery) -> Result<Vec<models::GetPersonsDuplicatesDataItem>> {
let path = "/persons/duplicates".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all groups a member is in
///
/// `GET /persons/{personId}/groups`
///
/// This endpoint returns an array with all groups the user is in.
///
/// Use [`Self::list_groups_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-groups");
/// for group in client.persons().list_groups(42)? {
/// println!("{}", group.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_groups(&self, person_id: impl Display) -> Result<Vec<models::GroupMember>> {
self.list_groups_with(person_id, &Default::default())
}
/// Get all groups a member is in
///
/// Like [`Self::list_groups`], with query parameters.
///
/// `GET /persons/{personId}/groups`
///
/// This endpoint returns an array with all groups the user is in.
pub fn list_groups_with(&self, person_id: impl Display, query: &GetPersonsIdGroupsQuery) -> Result<Vec<models::GroupMember>> {
let path = format!("/persons/{}/groups", seg(person_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get my unanswered meeting invitations
///
/// `GET /persons/{personId}/openmeetingrequests`
///
/// Lists meeting invitations for the authenticated person that have no response date and still have an occurrence found by recurrence calculation. personId must match the current user; querying another person returns 403, including for administrators. Tentative answers are excluded because they already have a response date. Invitations apply to the stored appointment or series, not separately to every occurrence. Results include nextStartDate and nextEndDate, are sorted by nextStartDate ascending, and are not paginated. The embedded appointment and legacy eventDate describe the stored appointment, which can start in the past for a recurring series.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-openmeetingrequests");
/// for open_meeting_request in client.persons().list_open_meeting_requests(42)? {
/// println!("{}", open_meeting_request.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_open_meeting_requests(&self, person_id: impl Display) -> Result<Vec<models::OpenMeetingRequest>> {
let path = format!("/persons/{}/openmeetingrequests", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Returns the posts authored by a person
///
/// `GET /persons/{personId}/posts`
///
/// Use [`Self::list_posts_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-posts");
/// for post in client.persons().list_posts("abc123")? {
/// println!("{}", post.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_posts(&self, person_id: impl Display) -> Result<Vec<models::Post>> {
self.list_posts_with(person_id, &Default::default())
}
/// Returns the posts authored by a person
///
/// Like [`Self::list_posts`], with query parameters.
///
/// `GET /persons/{personId}/posts`
pub fn list_posts_with(&self, person_id: impl Display, query: &GetPersonsPersonIdPostsQuery) -> Result<Vec<models::Post>> {
let path = format!("/persons/{}/posts", seg(person_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all relationships for all persons
///
/// `GET /persons/relationships`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-relationships");
/// for relationship in client.persons().list_relationships()? {
/// println!("{:?}", relationship.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_relationships(&self) -> Result<Vec<models::GetPersonsRelationshipsDataItem>> {
let path = "/persons/relationships".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// `GET /persons/search_old`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-search_old");
/// for search_old in client.persons().list_search_old()? {
/// println!("{:?}", search_old);
/// }
/// # Ok(())
/// # }
/// ```
#[deprecated = "GET /persons/search_old is deprecated in the ChurchTools API."]
pub fn list_search_old(&self) -> Result<Vec<i64>> {
let path = "/persons/search_old".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Updates a person
///
/// `PATCH /persons/{personId}`
///
/// Endpoint to update a person in ChurchTools. Generally, you can provide any information to save, but be aware that you can only save information for fields you have write access to. Beware, that not all fields which are listed in the Person schema can be updated. E.g. `imageUrl` or `familyUrl`.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("patch-persons-id");
/// let body = models::PatchPersonsIdBody {
/// title: Some("Hauskreis Nord".into()),
/// ..Default::default()
/// };
/// let result = client.persons().patch(42, &body)?;
/// println!("{:?}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, person_id: impl Display, body: &models::PatchPersonsIdBody) -> Result<models::Person> {
let path = format!("/persons/{}", seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
/// Retrieve person account properties
///
/// `POST /persons/properties`
///
/// Returns lightweight account and communication properties for the given person IDs. The response object is keyed by person ID. If `ids` is empty or omitted, no person properties are returned.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-persons-properties");
/// let body = models::PostPersonsPropertiesBody::default();
/// let result = client.persons().properties(&body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn properties(&self, body: &models::PostPersonsPropertiesBody) -> Result<std::collections::BTreeMap<String, models::PersonProperties>> {
let path = "/persons/properties".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Accept the current person's confidentiality agreement
///
/// `PUT /persons/{personId}/confidentialityagreement`
///
/// Records the current database date as the selected person’s confidentiality acceptance date. Only the current person can accept; simulation is rejected and administrators cannot accept for another person. Repeated acceptance overwrites the date. This is separate from privacy consent and takes no request body.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().update_confidentiality_agreement(42)?;
/// # Ok(())
/// # }
/// ```
pub fn update_confidentiality_agreement(&self, person_id: impl Display) -> Result<()> {
let path = format!("/persons/{}/confidentialityagreement", seg(person_id));
let query: Query = Query::new();
self.client.request(Method::Put, &path, &query, None).map(|_| ())
}
/// Change the password for the active account
///
/// `PUT /persons/{personId}/password`
///
/// Changes the password for the account in the password-reset session, or otherwise the currently signed-in account. The personId path value is currently ignored and does not select the target account. A reset session takes precedence over a signed-in session; in that case oldPassword must be an empty string. Without a reset session, oldPassword must match the current password (or be empty if none exists). The new password must meet the installation’s minimum_password_length (default 8), contain ASCII upper- and lowercase letters and a digit, and exclude the person’s first name, last name and nickname case-insensitively. A successful change normally invalidates all sessions and persistent login tokens and signs out the affected current user. Initial setup from no password or the default admin password retains sessions unless using a reset session. Ordinary user simulation is forbidden; support-user simulation is exempt.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PersonPasswordUpdate {
/// new_password: "ExamplePassword42".into(),
/// new_password_confirm: "ExamplePassword42".into(),
/// old_password: "PreviousPassword41".into(),
/// ..Default::default()
/// };
/// client.persons().update_password(42, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update_password(&self, person_id: impl Display, body: &models::PersonPasswordUpdate) -> Result<()> {
let path = format!("/persons/{}/password", seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
/// Record privacy consent
///
/// `PUT /persons/{personId}/privacypolicy`
///
/// Records consent for the selected person and optionally their children. The consent banner must be enabled. The requester must be the person themselves at age 16 or above, a super administrator, or a parent authorized through relationship type 1. For own consent, a missing birthday must be supplied and the controller separately checks the age; a request can return 204 without recording own consent when that check does not pass. Children are checked against parent/child relationship type 1, missing prior consent and age below 16. If any child marked accepted is processed, 200 returns per-child outcomes, including errors or not allowed. Otherwise 204 has no body. The flow is not atomic; own consent or birthdays may already have changed when a later step fails. Unlike GET and DELETE, the acceptance policy has no explicit simulation prohibition.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PersonPrivacyPolicyUpdate {
/// children_accepted: false,
/// own_accepted: true,
/// persons: vec![models::PersonPrivacyPolicyChildUpdate {
/// accepted: true,
/// birthday: "2016-05-14".into(),
/// edit_birthday: false,
/// id: 43,
/// ..Default::default()
/// }],
/// type_id: 2,
/// who_id: 1,
/// ..Default::default()
/// };
/// let result = client.persons().update_privacy_policy(42, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update_privacy_policy(&self, person_id: impl Display, body: &models::PersonPrivacyPolicyUpdate) -> Result<Option<Vec<models::PersonPrivacyPolicyChildResult>>> {
let path = format!("/persons/{}/privacypolicy", seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.persons().absences()`
#[derive(Clone, Copy)]
pub struct PersonsAbsencesResource<'a> {
client: &'a Client,
}
impl<'a> PersonsAbsencesResource<'a> {
/// Create new absence for person
///
/// `POST /persons/{personId}/absences`
///
/// Creates an absence for the person. Access requires the person themselves or "manage absent" or "churchservice +view absence" permission together with access to the person.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-persons-personId-absences");
/// let body = models::AbsenceCreate {
/// absence_reason_id: 1,
/// ..Default::default()
/// };
/// let result = client.persons().absences().create(42, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, person_id: impl Display, body: &models::AbsenceCreate) -> Result<models::Absence> {
let path = format!("/persons/{}/absences", seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete absence
///
/// `DELETE /persons/{personId}/absences/{id}`
///
/// Deletes the absence belonging to the person. Access requires the person themselves or "manage absent" or "churchservice +view absence" permission together with access to the person.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().absences().delete(42, 1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display, id: impl Display) -> Result<()> {
self.delete_with(person_id, id, &Default::default())
}
/// Delete absence
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /persons/{personId}/absences/{id}`
///
/// Deletes the absence belonging to the person. Access requires the person themselves or "manage absent" or "churchservice +view absence" permission together with access to the person.
pub fn delete_with(&self, person_id: impl Display, id: impl Display, query: &DeletePersonsPersonIdAbsencesIdQuery) -> Result<()> {
let path = format!("/persons/{}/absences/{}", seg(person_id), seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Fetch one absence
///
/// `GET /persons/{personId}/absences/{id}`
///
/// Returns the absence belonging to the person. Access requires the person themselves or "manage absent" or "churchservice +view absence" permission together with access to the person.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-absences-id");
/// let absence = client.persons().absences().get(42, 1)?;
/// println!("{}", absence.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display, id: impl Display) -> Result<models::Absence> {
let path = format!("/persons/{}/absences/{}", seg(person_id), seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Fetch all absences for a person
///
/// `GET /persons/{personId}/absences`
///
/// Returns this person’s absences that overlap the requested date range, sorted by start. Access requires the person themselves or "manage absent" or "churchservice +view absence" permission together with access to the person.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-absences");
/// for absence in client.persons().absences().list(42)? {
/// println!("{}", absence.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<models::Absence>> {
self.list_with(person_id, &Default::default())
}
/// Fetch all absences for a person
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /persons/{personId}/absences`
///
/// Returns this person’s absences that overlap the requested date range, sorted by start. Access requires the person themselves or "manage absent" or "churchservice +view absence" permission together with access to the person.
pub fn list_with(&self, person_id: impl Display, query: &GetPersonsPersonIdAbsencesQuery) -> Result<Vec<models::Absence>> {
let path = format!("/persons/{}/absences", seg(person_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update absence
///
/// `PUT /persons/{personId}/absences/{id}`
///
/// Replaces an absence belonging to the person. Access requires the person themselves or "manage absent" or "churchservice +view absence" permission together with access to the person.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-persons-personId-absences-id");
/// let body = models::AbsenceUpdate {
/// absence_reason_id: 1,
/// ..Default::default()
/// };
/// let result = client.persons().absences().update(42, 1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, person_id: impl Display, id: impl Display, body: &models::AbsenceUpdate) -> Result<models::Absence> {
let path = format!("/persons/{}/absences/{}", seg(person_id), seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.persons().devices()`
#[derive(Clone, Copy)]
pub struct PersonsDevicesResource<'a> {
client: &'a Client,
}
impl<'a> PersonsDevicesResource<'a> {
/// Delete device for person
///
/// `DELETE /persons/{personId}/devices/{deviceId}`
///
/// Removes the registration identified by personId/deviceId. Requires the person themselves, a super administrator, or administer persons permission. An unknown registration is a successful no-op. Returns 204 without a response body; no other device registrations are deleted.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().devices().delete(42, "abc123")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display, device_id: impl Display) -> Result<()> {
let path = format!("/persons/{}/devices/{}", seg(person_id), seg(device_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get specified device
///
/// `GET /persons/{personId}/devices/{deviceId}`
///
/// Returns the device identified by the personId/deviceId pair. Requires the same person-settings read access as the device list. Unknown registrations return 404. deviceId is the registration identifier; the deprecated response id is actually the push token. Reading does not refresh expiration.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-devices-deviceId");
/// let device = client.persons().devices().get(42, "abc123")?;
/// println!("{:?}", device.app_version);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display, device_id: impl Display) -> Result<models::Device> {
let path = format!("/persons/{}/devices/{}", seg(person_id), seg(device_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all registered devices for person
///
/// `GET /persons/{personId}/devices`
///
/// Lists all device registrations stored for the person, including registrations whose expirationDate has passed until cleanup removes them. Requires access to the person’s settings: the person themselves, a super administrator, or someone with administer persons permission. The read policy also accepts the special person ID -1. There is no pagination or guaranteed order, and this operation does not refresh expiration.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-devices");
/// for device in client.persons().devices().list(42)? {
/// println!("{:?}", device.app_version);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<models::Device>> {
let path = format!("/persons/{}/devices", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Create or update new device for person
///
/// `PUT /persons/{personId}/devices/{deviceId}`
///
/// Creates or refreshes the registration identified by personId/deviceId and returns the person’s complete device list. Requires access to update the person’s settings: the person themselves, a super administrator, or someone with administer persons permission. type is required on every call. Expiration is extended by three months, or one day during simulation. Omitted pushId becomes deviceId; empty pushId preserves the previous token; null clears it. Omitted appVersion clears the previous version. Other registrations of the same person with the same non-null push token are removed. Saving is transactional. When chat is active, a supplied appVersion outside simulation also sets the person’s hasMatrixUser setting.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::DeviceUpdate {
/// r#type: "FCM".into(),
/// ..Default::default()
/// };
/// for device in client.persons().devices().update(42, "abc123", &body)? {
/// println!("{:?}", device.app_version);
/// }
/// # Ok(())
/// # }
/// ```
pub fn update(&self, person_id: impl Display, device_id: impl Display, body: &models::DeviceUpdate) -> Result<Vec<models::Device>> {
let path = format!("/persons/{}/devices/{}", seg(person_id), seg(device_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.persons().events()`
#[derive(Clone, Copy)]
pub struct PersonsEventsResource<'a> {
client: &'a Client,
}
impl<'a> PersonsEventsResource<'a> {
pub fn services(&self) -> PersonsEventsServicesResource<'a> {
PersonsEventsServicesResource { client: self.client }
}
/// Get events that person is involved with
///
/// `GET /persons/{personId}/events`
///
/// Returns an unpaginated list of non-cancelled events where the person has a valid assignment. Requires the current user to be this person or a super administrator. from defaults to today and is compared strictly to midnight: an event exactly at midnight is excluded, later events that day are included. Results are ordered by event start ascending with no upper date bound. Visible service assignments are always included under eventServices and are not restricted to just this person. eventFiles is present but this endpoint does not load files, so it is empty. meta.count is the number returned.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-events");
/// for event in client.persons().events().list(42)? {
/// println!("{}", event.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<models::EventReadWithServices>> {
self.list_with(person_id, &Default::default())
}
/// Get events that person is involved with
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /persons/{personId}/events`
///
/// Returns an unpaginated list of non-cancelled events where the person has a valid assignment. Requires the current user to be this person or a super administrator. from defaults to today and is compared strictly to midnight: an event exactly at midnight is excluded, later events that day are included. Results are ordered by event start ascending with no upper date bound. Visible service assignments are always included under eventServices and are not restricted to just this person. eventFiles is present but this endpoint does not load files, so it is empty. meta.count is the number returned.
pub fn list_with(&self, person_id: impl Display, query: &GetPersonsIdEventsQuery) -> Result<Vec<models::EventReadWithServices>> {
let path = format!("/persons/{}/events", seg(person_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.persons().events().services()`
#[derive(Clone, Copy)]
pub struct PersonsEventsServicesResource<'a> {
client: &'a Client,
}
impl<'a> PersonsEventsServicesResource<'a> {
pub fn exchange_requests(&self) -> PersonsEventsServicesExchangeRequestsResource<'a> {
PersonsEventsServicesExchangeRequestsResource { client: self.client }
}
/// Get a person’s assignments in an event
///
/// `GET /persons/{personId}/events/{eventId}/services`
///
/// Returns the valid assignments of this person in a non-cancelled event, including both outstanding and confirmed assignments. Requires the current user to be this person or a super administrator. Unknown or cancelled events produce an empty list; related person and event objects are not enriched.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-events-id-services");
/// for service in client.persons().events().services().list(42, 42)? {
/// println!("{:?}", service.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display, event_id: impl Display) -> Result<Vec<models::ServiceRequest>> {
let path = format!("/persons/{}/events/{}/services", seg(person_id), seg(event_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.persons().events().services().exchange_requests()`
#[derive(Clone, Copy)]
pub struct PersonsEventsServicesExchangeRequestsResource<'a> {
client: &'a Client,
}
impl<'a> PersonsEventsServicesExchangeRequestsResource<'a> {
/// Create a new service exchange request
///
/// `POST /persons/{personId}/events/{eventId}/services/{serviceId}/exchangerequests`
///
/// Creates an `UNANSWERED` exchange request and sends the request notification. Requires the current user to be assigned to the source assignment. The target requestedServiceId is an event-service assignment ID, as returned by the candidates endpoint. Creating the request does not change either assignment.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ServiceExchangeRequestCreate {
/// requested_service_id: 42,
/// ..Default::default()
/// };
/// let result = client.persons().events().services().exchange_requests().create(42, 42, 42, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, person_id: impl Display, event_id: impl Display, service_id: impl Display, body: &models::ServiceExchangeRequestCreate) -> Result<models::ServiceExchangeRequest> {
let path = format!("/persons/{}/events/{}/services/{}/exchangerequests", seg(person_id), seg(event_id), seg(service_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a service exchange request
///
/// `DELETE /persons/{personId}/events/{eventId}/services/{serviceId}/exchangerequests/{requestId}`
///
/// Cancels the exchange by setting status to `CANCELLED` and sending a cancellation notification. Requires the current user to be assigned to the source `serviceId`. With hardDelete=`true`, removes the request matching both `requestId` and the source assignment instead, without a cancellation notification. Neither action swaps the assigned persons. Cancellation leaves the archive flag unchanged.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().events().services().exchange_requests().delete(42, 42, 42, 42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display, event_id: impl Display, service_id: impl Display, request_id: impl Display) -> Result<()> {
self.delete_with(person_id, event_id, service_id, request_id, &Default::default())
}
/// Delete a service exchange request
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /persons/{personId}/events/{eventId}/services/{serviceId}/exchangerequests/{requestId}`
///
/// Cancels the exchange by setting status to `CANCELLED` and sending a cancellation notification. Requires the current user to be assigned to the source `serviceId`. With hardDelete=`true`, removes the request matching both `requestId` and the source assignment instead, without a cancellation notification. Neither action swaps the assigned persons. Cancellation leaves the archive flag unchanged.
pub fn delete_with(&self, person_id: impl Display, event_id: impl Display, service_id: impl Display, request_id: impl Display, query: &DeletePersonsIdEventsIdServicesIdExchangerequestsIdQuery) -> Result<()> {
let path = format!("/persons/{}/events/{}/services/{}/exchangerequests/{}", seg(person_id), seg(event_id), seg(service_id), seg(request_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get all service exchange requests of a user for a service
///
/// `GET /persons/{personId}/events/{eventId}/services/{serviceId}/exchangerequests`
///
/// Returns incoming or outgoing exchange requests for the assignment identified by `serviceId`. Requires the current user to be assigned to it. The list is unpaginated and does not filter by status, archive flag or event date. Event and person details are enriched where available.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-events-id-services-id-exchangerequests");
/// for exchange_request in client.persons().events().services().exchange_requests().list(42, 42, 42)? {
/// println!("{}", exchange_request.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display, event_id: impl Display, service_id: impl Display) -> Result<Vec<models::ServiceExchangeRequest>> {
self.list_with(person_id, event_id, service_id, &Default::default())
}
/// Get all service exchange requests of a user for a service
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /persons/{personId}/events/{eventId}/services/{serviceId}/exchangerequests`
///
/// Returns incoming or outgoing exchange requests for the assignment identified by `serviceId`. Requires the current user to be assigned to it. The list is unpaginated and does not filter by status, archive flag or event date. Event and person details are enriched where available.
pub fn list_with(&self, person_id: impl Display, event_id: impl Display, service_id: impl Display, query: &GetPersonsIdEventsIdServicesIdExchangerequestsQuery) -> Result<Vec<models::ServiceExchangeRequest>> {
let path = format!("/persons/{}/events/{}/services/{}/exchangerequests", seg(person_id), seg(event_id), seg(service_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get candidates for service exchange request
///
/// `GET /persons/{personId}/events/{eventId}/services/{serviceId}/exchangerequests/candidates`
///
/// Returns an unpaginated list of assignments for the same reusable service as the source assignment. Requires the current user to be assigned to the source. Candidates have valid assignments with a non-`null` name, an event starting after midnight today, and a person other than `personId`. Hidden-person visibility is respected.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-events-id-services-id-exchangerequests-candidates");
/// for candidate in client.persons().events().services().exchange_requests().list_candidates(42, 42, 42)? {
/// println!("{}", candidate.event_date);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_candidates(&self, person_id: impl Display, event_id: impl Display, service_id: impl Display) -> Result<Vec<models::ServiceExchangeCandidate>> {
let path = format!("/persons/{}/events/{}/services/{}/exchangerequests/candidates", seg(person_id), seg(event_id), seg(service_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.persons().exchange_requests()`
#[derive(Clone, Copy)]
pub struct PersonsExchangeRequestsResource<'a> {
client: &'a Client,
}
impl<'a> PersonsExchangeRequestsResource<'a> {
/// Decline a service exchange request
///
/// `DELETE /persons/{personId}/exchangerequests/{requestId}`
///
/// Declines the exchange by setting its status to `DECLINED` and sending a notification. The request remains stored and its archive flag is unchanged; the assignments are not swapped. Requires `personId` to identify the current user and the person assigned to the requested assignment. Returns the updated exchange request without enriching events or persons. Already answered requests are returned unchanged.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let exchange_request = client.persons().exchange_requests().delete(42, 42)?;
/// println!("{}", exchange_request.id);
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display, request_id: impl Display) -> Result<models::ServiceExchangeRequest> {
let path = format!("/persons/{}/exchangerequests/{}", seg(person_id), seg(request_id));
let query: Query = Query::new();
self.client.request_data(Method::Delete, &path, &query, None)
}
/// Get all service exchange requests for a user
///
/// `GET /persons/{personId}/exchangerequests`
///
/// Returns an unpaginated list of incoming or outgoing exchanges for the current user; `personId` must identify that user. Both assignments must still be valid, the exchange must not be archived, and at least one event must start today or later. Status is not restricted to `UNANSWERED`. Event and person details are enriched where available.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-exchangerequests");
/// for exchange_request in client.persons().exchange_requests().list(42)? {
/// println!("{}", exchange_request.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<models::ServiceExchangeRequest>> {
self.list_with(person_id, &Default::default())
}
/// Get all service exchange requests for a user
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /persons/{personId}/exchangerequests`
///
/// Returns an unpaginated list of incoming or outgoing exchanges for the current user; `personId` must identify that user. Both assignments must still be valid, the exchange must not be archived, and at least one event must start today or later. Status is not restricted to `UNANSWERED`. Event and person details are enriched where available.
pub fn list_with(&self, person_id: impl Display, query: &GetPersonsIdExchangerequestsQuery) -> Result<Vec<models::ServiceExchangeRequest>> {
let path = format!("/persons/{}/exchangerequests", seg(person_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Accept a service exchange request
///
/// `PUT /persons/{personId}/exchangerequests/{requestId}`
///
/// Accepts the exchange and swaps the persons assigned to the two event-service assignments, confirming both assignments. The workflow archives the accepted exchange and other active exchanges from the same source assignment, and sends notifications. Requires `personId` to identify the current user and the person assigned to the requested assignment. Returns the updated exchange request without enriching events or persons.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let result = client.persons().exchange_requests().update(42, 42)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, person_id: impl Display, request_id: impl Display) -> Result<models::ServiceExchangeRequest> {
let path = format!("/persons/{}/exchangerequests/{}", seg(person_id), seg(request_id));
let query: Query = Query::new();
self.client.request_data(Method::Put, &path, &query, None)
}
}
/// `client.persons().external_logins()`
#[derive(Clone, Copy)]
pub struct PersonsExternalLoginsResource<'a> {
client: &'a Client,
}
impl<'a> PersonsExternalLoginsResource<'a> {
/// Unlink an external login provider from a person
///
/// `DELETE /persons/{personId}/external-logins/{externalLoginId}`
///
/// Removes this person’s identity mapping for the selected external-login provider. Requires the person themselves, a super administrator, or administer persons permission. A missing mapping returns 404, including on repeated deletion. The provider itself is retained. The method does not end existing sessions or verify that another login method remains available. A later external login is handled by the provider’s normal matching/linking workflow.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().external_logins().delete(42, 7)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display, external_login_id: impl Display) -> Result<()> {
let path = format!("/persons/{}/external-logins/{}", seg(person_id), seg(external_login_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get linked external login providers
///
/// `GET /persons/{personId}/external-logins`
///
/// Lists the external identity providers linked to the person. Requires access to the person’s settings: the person themselves, a super administrator, or administer persons permission; the read policy also permits personId=-1. Hidden providers are included when a mapping exists. This is a list of identity links, not a list of all configured login options. No pagination or guaranteed order applies. Person existence is not checked separately; no mappings returns an empty list.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-external-logins");
/// for external_login in client.persons().external_logins().list(42)? {
/// println!("{}", external_login.external_login_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<models::ExternalLoginPersonMapping>> {
let path = format!("/persons/{}/external-logins", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.persons().followups()`
#[derive(Clone, Copy)]
pub struct PersonsFollowupsResource<'a> {
client: &'a Client,
}
impl<'a> PersonsFollowupsResource<'a> {
/// Create a follow-up concerning a person
///
/// `POST /persons/{personId}/followups`
///
/// Creates a task concerning this person without a group or membership context. The subject person is distinct from ownerId, which identifies who should handle the task. Requires permission to view the person; a configured success group additionally requires permission to add members there, or the corresponding group-type permission. Missing/null ownerId assigns the task to the current user. A new specification is created from the title and display/success settings. A due date is optional and may lie in the past. Configuring a success group does not itself add a membership; the completion request must explicitly select the target group.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-persons-personId-followups");
/// let body = models::FollowUpCreate {
/// title: "Call Peter".into(),
/// ..Default::default()
/// };
/// let result = client.persons().followups().create(42, &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, person_id: impl Display, body: &models::FollowUpCreate) -> Result<models::FollowUp2> {
let path = format!("/persons/{}/followups", seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Get follow-up counts for a person
///
/// `GET /persons/{personId}/followups/statistics`
///
/// Counts follow-ups concerning this person, including tasks linked to group memberships. Requires permission to view the person. Counts are restricted to tasks assigned to the current user and unassigned tasks in groups where that user has follow-up rights; tasks assigned to other people are omitted. Archived subject persons are excluded. Counts cover all matching tasks independently of list pagination and state filters. Due categories use the effective due date and the server’s current date. countDone includes both completed and dismissed tasks. Empty results return zero for every category.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-followups-statistics");
/// let statistic = client.persons().followups().get_statistics(42)?;
/// println!("{}", statistic.count_done);
/// # Ok(())
/// # }
/// ```
pub fn get_statistics(&self, person_id: impl Display) -> Result<models::FollowUpStatistics> {
let path = format!("/persons/{}/followups/statistics", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get a person's follow-ups
///
/// `GET /persons/{personId}/followups`
///
/// Lists tasks concerning this person, including tasks linked to group memberships. The subject person is distinct from ownerId, which identifies who handles the task. Requires permission to view the person. Results are restricted to tasks assigned to the current user and unassigned tasks in groups where that user has follow-up rights; tasks assigned to others are omitted even if individually viewable. Archived subject persons are excluded. State filters are combined with OR; omission includes all states. Results are ordered by completion date descending, effective due date ascending, then ID. Pagination returns meta.count for this page only, without a total or last-page value.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-followups");
/// for followup in client.persons().followups().list(42)? {
/// println!("{}", followup.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<models::FollowUp2>> {
self.list_with(person_id, &Default::default())
}
/// Get a person's follow-ups
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /persons/{personId}/followups`
///
/// Lists tasks concerning this person, including tasks linked to group memberships. The subject person is distinct from ownerId, which identifies who handles the task. Requires permission to view the person. Results are restricted to tasks assigned to the current user and unassigned tasks in groups where that user has follow-up rights; tasks assigned to others are omitted even if individually viewable. Archived subject persons are excluded. State filters are combined with OR; omission includes all states. Results are ordered by completion date descending, effective due date ascending, then ID. Pagination returns meta.count for this page only, without a total or last-page value.
pub fn list_with(&self, person_id: impl Display, query: &GetPersonsPersonIdFollowupsQuery) -> Result<Vec<models::FollowUp2>> {
let path = format!("/persons/{}/followups", seg(person_id));
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get a person's follow-ups
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, person_id: impl Display, query: &GetPersonsPersonIdFollowupsQuery) -> Items<models::FollowUp2> {
let path = format!("/persons/{}/followups", seg(person_id));
self.client.items(&path, query.to_query())
}
}
/// `client.persons().merge()`
#[derive(Clone, Copy)]
pub struct PersonsMergeResource<'a> {
client: &'a Client,
}
impl<'a> PersonsMergeResource<'a> {
/// Get information to compare two person records in order to prepare a merge
///
/// `GET /persons/{personId}/merge/{duplicateId}`
///
/// **Caution:** This API is published as Beta and subject to be changed. It is published such that customers can play evaluate it with production data.
///
/// This retrieves the basis for a merge of two person records You will receive person data, relationships, groups etc. for both persons.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personid-merge-duplicateid");
/// let merge = client.persons().merge().get("abc123", "100")?;
/// println!("{:?}", merge);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display, duplicate_id: impl Display) -> Result<models::PersonMergeInfo> {
let path = format!("/persons/{}/merge/{}", seg(person_id), seg(duplicate_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Merge two person records
///
/// `PATCH /persons/{personId}/merge/{duplicateId}`
///
/// **Caution:** This API is published as Beta and subject to be changed. It is published such that customers can play evaluate it with production data.
///
/// Generally, you can provide any person field to save, but be aware that write access to the provided ields is required. Beware, that not all fields which are listed in the Person schema can be updated. E.g. `imageUrl` or `familyUrl`
/// (see `PATCH /api/person/{id}`)
///
/// * using PATCH you can perform the eventual merge, it will
/// + patch the person record
/// + replace the personId of the doublette with the Original in all related records.
/// * Group memberships
/// * Person relation
/// * Bookings
/// * Wiki-Entries
/// * Financial transactions
/// * ...
/// * delete the doublette if `deleteDuplicate` is true
///
/// all to be done within one transaction.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PersonUpdateable {
/// title: Some("Hauskreis Nord".into()),
/// ..Default::default()
/// };
/// let result = client.persons().merge().patch("abc123", "100", &body)?;
/// println!("{}", result.body);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, person_id: impl Display, duplicate_id: impl Display, body: &models::PersonUpdateable) -> Result<models::PatchPersonsPersonidMergeDuplicateidData> {
let path = format!("/persons/{}/merge/{}", seg(person_id), seg(duplicate_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
}
/// `client.persons().relationships()`
#[derive(Clone, Copy)]
pub struct PersonsRelationshipsResource<'a> {
client: &'a Client,
}
impl<'a> PersonsRelationshipsResource<'a> {
/// Create new relationship for person
///
/// `POST /persons/{personId}/relationships`
///
/// Create a new relationship between the specified person and another person.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-persons-personId-relationships");
/// let body = models::PostPersonsPersonIdRelationshipsBody {
/// other_person_id: 42,
/// relationship_type_id: 42,
/// ..Default::default()
/// };
/// let result = client.persons().relationships().create(42, &body)?;
/// println!("{:?}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, person_id: impl Display, body: &models::PostPersonsPersonIdRelationshipsBody) -> Result<models::GetPersonsRelationshipsDataItem> {
let path = format!("/persons/{}/relationships", seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete specified relationship
///
/// `DELETE /persons/{personId}/relationships/{relationshipId}`
///
/// Delete the specified relationship.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().relationships().delete(42, 18)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display, relationship_id: impl Display) -> Result<()> {
let path = format!("/persons/{}/relationships/{}", seg(person_id), seg(relationship_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get all relationships linked to this person
///
/// `GET /persons/{personId}/relationships`
///
/// Returns all relationships of the specified person. The result is sorted by 1. the `sortkey` of the relationship type, 2. last name, and 3. first name of a person.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-personId-relationships");
/// for relationship in client.persons().relationships().list(42)? {
/// println!("{}", relationship.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<models::PersonRelationship>> {
let path = format!("/persons/{}/relationships", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.persons().service_requests()`
#[derive(Clone, Copy)]
pub struct PersonsServiceRequestsResource<'a> {
client: &'a Client,
}
impl<'a> PersonsServiceRequestsResource<'a> {
/// Decline a service request for a person
///
/// `DELETE /persons/{personId}/servicerequests/{requestId}`
///
/// Declines the current assignment and returns HTTP 200 with a new unassigned record: person and name are null, isValid=true and isAccepted=false. The original requestId becomes invalid. Related exchange requests are deleted and the workflow sends notifications. Requires permission to decline; assigned persons additionally need allowDecline on the service unless another permission grants access. Invalid records return 404 and unassigned slots return 422.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let service_request = client.persons().service_requests().delete(42, 42)?;
/// println!("{:?}", service_request.name);
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display, request_id: impl Display) -> Result<models::ServiceRequest> {
self.delete_with(person_id, request_id, &Default::default())
}
/// Decline a service request for a person
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /persons/{personId}/servicerequests/{requestId}`
///
/// Declines the current assignment and returns HTTP 200 with a new unassigned record: person and name are null, isValid=true and isAccepted=false. The original requestId becomes invalid. Related exchange requests are deleted and the workflow sends notifications. Requires permission to decline; assigned persons additionally need allowDecline on the service unless another permission grants access. Invalid records return 404 and unassigned slots return 422.
pub fn delete_with(&self, person_id: impl Display, request_id: impl Display, query: &DeletePersonsIdServicerequestsIdQuery) -> Result<models::ServiceRequest> {
let path = format!("/persons/{}/servicerequests/{}", seg(person_id), seg(request_id));
let query: Query = query.to_query();
self.client.request_data(Method::Delete, &path, &query, None)
}
/// Get a specific service request for a person
///
/// `GET /persons/{personId}/servicerequests/{requestId}`
///
/// Returns the assignment identified by requestId and personId when the viewer has access. Unlike the list endpoint, this lookup can return invalid historical records. Comments are null if the viewer cannot see the reason.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-servicerequests-id");
/// let service_request = client.persons().service_requests().get(42, 42)?;
/// println!("{:?}", service_request.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display, request_id: impl Display) -> Result<models::ServiceRequest> {
let path = format!("/persons/{}/servicerequests/{}", seg(person_id), seg(request_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all service requests for a person
///
/// `GET /persons/{personId}/servicerequests`
///
/// Returns an unpaginated list of visible, valid assignments for this person, including both outstanding and confirmed requests. Declined and superseded records are excluded. Sorted by event start ascending. only_future=true starts at midnight today, so events earlier today are included. meta.count is the number returned after permission filtering.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-servicerequests");
/// for service_request in client.persons().service_requests().list(42)? {
/// println!("{:?}", service_request.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<models::ServiceRequest>> {
self.list_with(person_id, &Default::default())
}
/// Get all service requests for a person
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /persons/{personId}/servicerequests`
///
/// Returns an unpaginated list of visible, valid assignments for this person, including both outstanding and confirmed requests. Declined and superseded records are excluded. Sorted by event start ascending. only_future=true starts at midnight today, so events earlier today are included. meta.count is the number returned after permission filtering.
pub fn list_with(&self, person_id: impl Display, query: &GetPersonsIdServicerequestsQuery) -> Result<Vec<models::ServiceRequest>> {
let path = format!("/persons/{}/servicerequests", seg(person_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Undo last service request action
///
/// `POST /persons/{personId}/servicerequests/{requestId}/undo`
///
/// Reverts the last acceptance or decline to an outstanding request. Only the assigned person may do this. The legacy history must identify this as the last action and its timestamp must be within the 10-minute undo window; otherwise 400 is returned. For a decline, use the original declined request ID, not the new unassigned record returned by the decline operation. The automatically created empty record is removed when undoing a decline. Returns the legacy response shape ServiceRequestUndoResult.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let service_request = client.persons().service_requests().undo(42, 42)?;
/// println!("{:?}", service_request.name);
/// # Ok(())
/// # }
/// ```
pub fn undo(&self, person_id: impl Display, request_id: impl Display) -> Result<models::ServiceRequestUndoResult> {
let path = format!("/persons/{}/servicerequests/{}/undo", seg(person_id), seg(request_id));
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
/// Update a service assignment
///
/// `PUT /persons/{personId}/servicerequests/{requestId}`
///
/// Creates a replacement assignment and invalidates the previous active record for the same event, service and slot index. Always use the returned ID for subsequent actions. isAccepted=true confirms it; false leaves it awaiting confirmation and does not decline it. Notifications follow the assignment workflow. Updating an occupied slot requires permission to update that assignment; free slots use the self-assignment policy, and target-person restrictions apply. The legacy agreed input is accepted as an alias for isAccepted.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PersonServiceRequestUpdate {
/// comment: Some(Some("Hallo zusammen".into())),
/// ..Default::default()
/// };
/// let result = client.persons().service_requests().update(42, 42, &body)?;
/// println!("{:?}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, person_id: impl Display, request_id: impl Display, body: &models::PersonServiceRequestUpdate) -> Result<models::ServiceRequest> {
let path = format!("/persons/{}/servicerequests/{}", seg(person_id), seg(request_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.persons().settings()`
#[derive(Clone, Copy)]
pub struct PersonsSettingsResource<'a> {
client: &'a Client,
}
impl<'a> PersonsSettingsResource<'a> {
pub fn two_factor(&self) -> PersonsSettingsTwoFactorResource<'a> {
PersonsSettingsTwoFactorResource { client: self.client }
}
/// Delete a person setting
///
/// `DELETE /persons/{personId}/settings/{module}/{attribute}`
///
/// Deletes the exact stored setting and returns 204, including if it did not exist. Requires the person themselves, a super administrator, or administer persons permission. The administer global views (churchgroup) exception also applies to churchdb/group-custom-views without restricting the target person. Unlike PUT, DELETE does not enforce the setting write allowlist. No setting-specific update hook is run.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().settings().delete(42, "beispiel", "beispiel")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display, module: impl Display, attribute: impl Display) -> Result<()> {
let path = format!("/persons/{}/settings/{}/{}", seg(person_id), seg(module), seg(attribute));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get person setting
///
/// `GET /persons/{personId}/settings/{module}/{attribute}`
///
/// Requires access to the person’s settings: the person themselves, a super administrator, or administer persons permission. The special person ID -1 is also readable by authenticated users. Returns the exact stored module/attribute pair. A missing setting returns 404 rather than a default value. Readability does not mean the setting can be changed through the PUT endpoint.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-settings-module-attribute");
/// let setting = client.persons().settings().get(42, "beispiel", "beispiel")?;
/// println!("{}", setting.attribute);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display, module: impl Display, attribute: impl Display) -> Result<models::PersonSetting> {
let path = format!("/persons/{}/settings/{}/{}", seg(person_id), seg(module), seg(attribute));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all person settings of a module
///
/// `GET /persons/{personId}/settings/{module}`
///
/// Requires access to the person’s settings: the person themselves, a super administrator, or administer persons permission. The special person ID -1 is also readable by authenticated users. Returns stored settings in the exact module namespace as a flat list. Unknown or empty namespaces return an empty list. No pagination or guaranteed order is applied; the read endpoint is not restricted to the write allowlist.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-settings-module");
/// for module in client.persons().settings().get_module(42, "beispiel")? {
/// println!("{}", module.attribute);
/// }
/// # Ok(())
/// # }
/// ```
pub fn get_module(&self, person_id: impl Display, module: impl Display) -> Result<Vec<models::PersonSetting>> {
let path = format!("/persons/{}/settings/{}", seg(person_id), seg(module));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all person settings
///
/// `GET /persons/{personId}/settings`
///
/// Requires access to the person’s settings: the person themselves, a super administrator, or administer persons permission. The special person ID -1 is also readable by authenticated users. Returns all stored preferences as a flat list of module/attribute/value records. No pagination, guaranteed order, or write-allowlist filtering is applied. An empty list means no stored settings were found; person existence is not checked separately.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-settings");
/// for setting in client.persons().settings().list(42)? {
/// println!("{}", setting.attribute);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<models::PersonSetting>> {
let path = format!("/persons/{}/settings", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Create/Update person setting
///
/// `PUT /persons/{personId}/settings/{module}/{attribute}`
///
/// Creates or replaces one allowlisted setting; arbitrary module/attribute pairs return 400. Requires the person themselves, a super administrator, or administer persons permission. Additionally, administer global views (churchgroup) permits writes to churchdb/group-custom-views; the current policy does not restrict that exception to personId=-1. The response contains the value returned by the service, which can have a different JSON numeric type from a later GET. The three churchcal calendar-filter settings require JSON-array text and normalize referenced calendar IDs. See PersonSettingUpdate for supported pairs and value types.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-persons-id-settings-module-attribute");
/// let body = models::PersonSettingUpdate {
/// value: serde_json::json!("beispiel"),
/// ..Default::default()
/// };
/// let result = client.persons().settings().update(42, "push", "disableGroupSignUpNotifications", &body)?;
/// println!("{}", result.attribute);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, person_id: impl Display, module: impl Display, attribute: impl Display, body: &models::PersonSettingUpdate) -> Result<models::PersonSetting> {
let path = format!("/persons/{}/settings/{}/{}", seg(person_id), seg(module), seg(attribute));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.persons().settings().two_factor()`
#[derive(Clone, Copy)]
pub struct PersonsSettingsTwoFactorResource<'a> {
client: &'a Client,
}
impl<'a> PersonsSettingsTwoFactorResource<'a> {
/// Initialize an authenticator for the current person
///
/// `POST /persons/{personId}/settings/twofactor`
///
/// Verifies the current person’s username/email and password, then stores a new TOTP secret and sets twoFactorEnabled to false. Only the current person can initialize their own authenticator. Repeating this call replaces the previous secret and disables an already active authenticator. Keep the returned secret or QR code for enrollment, verify a generated code through POST /twofactor/totp, then call PUT on this path to activate. This step does not complete activation.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::LoginCredentials {
/// password: "example-password".into(),
/// username: "alex@example.org".into(),
/// ..Default::default()
/// };
/// let result = client.persons().settings().two_factor().create(42, &body)?;
/// println!("{}", result.qrcode);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, person_id: impl Display, body: &models::LoginCredentials) -> Result<models::TwoFactorSetupSecret> {
let path = format!("/persons/{}/settings/twofactor", seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Deactivate the current person’s authenticator
///
/// `DELETE /persons/{personId}/settings/twofactor`
///
/// Sets twoFactorEnabled to false and deletes the stored TOTP secret. Only the current person may deactivate their own authenticator. No password or authenticator code is consumed. Repeating the call is allowed. This does not clear an administrator’s twoFactorForce setting or group-role requirements, so a later login can require setup again.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.persons().settings().two_factor().delete(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display) -> Result<()> {
let path = format!("/persons/{}/settings/twofactor", seg(person_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get the person’s two-factor activation setting
///
/// `GET /persons/{personId}/settings/twofactor`
///
/// Returns the stored twoFactorEnabled setting, defaulting to false without storing it when absent. Requires access to the person’s settings (self, super administrator or administer persons; the global defaults person -1 is also allowed). This reports activation only, not whether two-factor authentication is required by an administrator or group role.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-settings-twofactor");
/// let two_factor = client.persons().settings().two_factor().get(42)?;
/// println!("{}", two_factor.attribute);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display) -> Result<models::PersonTwoFactorEnabled> {
let path = format!("/persons/{}/settings/twofactor", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get the person’s explicit two-factor requirement
///
/// `GET /persons/{personId}/settings/twofactor/force`
///
/// Returns the stored twoFactorForce setting, defaulting to false when absent. Requires churchcore administer persons or simulate persons. This is only the explicit person-level flag; an applicable group role may still require two-factor authentication when this value is false.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-persons-id-settings-twofactor-force");
/// let force = client.persons().settings().two_factor().get_force(42)?;
/// println!("{}", force.attribute);
/// # Ok(())
/// # }
/// ```
pub fn get_force(&self, person_id: impl Display) -> Result<models::PersonTwoFactorForce> {
let path = format!("/persons/{}/settings/twofactor/force", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Activate the current person’s initialized authenticator
///
/// `PUT /persons/{personId}/settings/twofactor`
///
/// Sets twoFactorEnabled to true and refreshes person session data. Only the current person may activate their own authenticator. A stored secret from initialization is required; otherwise 400 is returned. No request body is consumed. Clients should first verify an authenticator code with POST /twofactor/totp; this activation handler itself checks only that a secret exists, not that a code was previously verified. Existing login tokens and other sessions are not revoked.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let result = client.persons().settings().two_factor().update(42)?;
/// println!("{}", result.attribute);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, person_id: impl Display) -> Result<models::PersonTwoFactorEnabled> {
let path = format!("/persons/{}/settings/twofactor", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Put, &path, &query, None)
}
/// Set the person’s explicit two-factor requirement
///
/// `PUT /persons/{personId}/settings/twofactor/force`
///
/// Stores the explicit person-level two-factor requirement. Requires churchcore administer persons or simulate persons; only a super administrator may change this flag for another super administrator. Setting false does not remove a requirement inherited from a group role. This neither enrolls an authenticator nor changes twoFactorEnabled.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PersonTwoFactorForceUpdate {
/// value: true,
/// ..Default::default()
/// };
/// let result = client.persons().settings().two_factor().update_force(42, &body)?;
/// println!("{}", result.attribute);
/// # Ok(())
/// # }
/// ```
pub fn update_force(&self, person_id: impl Display, body: &models::PersonTwoFactorForceUpdate) -> Result<models::PersonTwoFactorForce> {
let path = format!("/persons/{}/settings/twofactor/force", seg(person_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.placeholders()`
#[derive(Clone, Copy)]
pub struct PlaceholdersResource<'a> {
client: &'a Client,
}
impl<'a> PlaceholdersResource<'a> {
pub fn group(&self) -> PlaceholdersGroupResource<'a> {
PlaceholdersGroupResource { client: self.client }
}
/// Get email placeholders
///
/// `GET /placeholders/email`
///
/// Returns the editor’s available email-template placeholders using an empty person context. No recipient values are rendered. The response data is a recursive menu: groups have name and items, selectable leaves have placeholder and label, optionally menuLabel. Labels are translated. Insert the supplied expression verbatim; ordinary values use triple braces, while block helpers use double braces. The set of fields depends on configuration, so names are not a fixed enum. This object-backed tree has no meta.count envelope.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-placeholders-email");
/// for email in client.placeholders().list_email()? {
/// println!("{}", email.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_email(&self) -> Result<Vec<models::PlaceholderMenuGroup>> {
let path = "/placeholders/email".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.placeholders().group()`
#[derive(Clone, Copy)]
pub struct PlaceholdersGroupResource<'a> {
client: &'a Client,
}
impl<'a> PlaceholdersGroupResource<'a> {
/// Get group placeholders
///
/// `GET /placeholders/group/{id}`
///
/// Returns the editor’s available group and group-membership placeholders, including this group’s custom membership fields. id must be numeric; GUIDs are not accepted by this controller. No group/member values are rendered. The handler loads the group without a separate group-visibility check. The response data is a recursive menu: groups have name and items, selectable leaves have placeholder and label, optionally menuLabel. Labels are translated. Insert the supplied expression verbatim; ordinary values use triple braces, while block helpers use double braces. The set of fields depends on configuration, so names are not a fixed enum. This object-backed tree has no meta.count envelope.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-placeholders-group-id");
/// for group in client.placeholders().group().get(11)? {
/// println!("{}", group.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<Vec<models::PlaceholderMenuGroup>> {
let path = format!("/placeholders/group/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.poll_for_news()`
#[derive(Clone, Copy)]
pub struct PollForNewsResource<'a> {
client: &'a Client,
}
impl<'a> PollForNewsResource<'a> {
/// `GET /pollfornews`
///
/// This endpoint returns the identifiers of changed entities since the last call.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-pollfornews");
/// let query = GetPollfornewsQuery {
/// domain_types: Some(vec!["beispiel".into()]),
/// since: Some("2022-10-19T12:00:00Z".parse()?),
/// ..Default::default()
/// };
/// for poll_for_new in client.poll_for_news().list(&query)? {
/// println!("{}", poll_for_new.domain_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetPollfornewsQuery) -> Result<Vec<models::PollForNewsResult>> {
let path = "/pollfornews".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.post()`
#[derive(Clone, Copy)]
pub struct PostResource<'a> {
client: &'a Client,
}
impl<'a> PostResource<'a> {
pub fn hidden(&self) -> PostHiddenResource<'a> {
PostHiddenResource { client: self.client }
}
pub fn reports(&self) -> PostReportsResource<'a> {
PostReportsResource { client: self.client }
}
/// `GET /post/linkings`
///
/// Use [`Self::get_linkings_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-post-linkings");
/// let result = client.post().get_linkings()?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_linkings(&self) -> Result<serde_json::Value> {
self.get_linkings_with(&Default::default())
}
/// `GET /post/linkings`
///
/// Like [`Self::get_linkings`], with query parameters.
pub fn get_linkings_with(&self, query: &GetPostLinkingsQuery) -> Result<serde_json::Value> {
let path = "/post/linkings".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// `GET /post/groups`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-post-groups");
/// for group in client.post().list_groups()? {
/// println!("{}", group.favorite_group);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_groups(&self) -> Result<Vec<models::PossiblePostGroup>> {
let path = "/post/groups".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// `GET /post/search`
///
/// Search posts
///
/// Use [`Self::list_search_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-post-search");
/// for search in client.post().list_search()? {
/// println!("{}", search.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_search(&self) -> Result<Vec<models::Post>> {
self.list_search_with(&Default::default())
}
/// `GET /post/search`
///
/// Like [`Self::list_search`], with query parameters.
///
/// Search posts
pub fn list_search_with(&self, query: &GetPostSearchQuery) -> Result<Vec<models::Post>> {
let path = "/post/search".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.post().hidden()`
#[derive(Clone, Copy)]
pub struct PostHiddenResource<'a> {
client: &'a Client,
}
impl<'a> PostHiddenResource<'a> {
/// `DELETE /post/hidden/{domainType}/{domainId}`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.post().hidden().delete("actor", 42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, domain_type: impl Display, domain_id: impl Display) -> Result<()> {
let path = format!("/post/hidden/{}/{}", seg(domain_type), seg(domain_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// `GET /post/hidden`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-post-hidden");
/// for hidden in client.post().hidden().list()? {
/// println!("{:?}", hidden);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<serde_json::Value>> {
let path = "/post/hidden".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.post().reports()`
#[derive(Clone, Copy)]
pub struct PostReportsResource<'a> {
client: &'a Client,
}
impl<'a> PostReportsResource<'a> {
/// `POST /post/reports`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ReportCreate {
/// domain_id: 42,
/// domain_type: "post".into(),
/// ..Default::default()
/// };
/// let result = client.post().reports().create(&body)?;
/// println!("{:?}", result.comment);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ReportCreate) -> Result<models::Report> {
let path = "/post/reports".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// `GET /post/reports`
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-post-reports");
/// for report in client.post().reports().list()? {
/// println!("{:?}", report);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<serde_json::Value>> {
self.list_with(&Default::default())
}
/// `GET /post/reports`
///
/// Like [`Self::list`], with query parameters.
pub fn list_with(&self, query: &GetPostReportsQuery) -> Result<Vec<serde_json::Value>> {
let path = "/post/reports".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// `PUT /post/reports/answer`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ReportAnswer {
/// domain_id: 42,
/// domain_type: "post".into(),
/// response: "accept".into(),
/// ..Default::default()
/// };
/// client.post().reports().update_answer(&body)?;
/// # Ok(())
/// # }
/// ```
pub fn update_answer(&self, body: &models::ReportAnswer) -> Result<()> {
let path = "/post/reports/answer".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.posts()`
#[derive(Clone, Copy)]
pub struct PostsResource<'a> {
client: &'a Client,
}
impl<'a> PostsResource<'a> {
pub fn comments(&self) -> PostsCommentsResource<'a> {
PostsCommentsResource { client: self.client }
}
pub fn hidden(&self) -> PostsHiddenResource<'a> {
PostsHiddenResource { client: self.client }
}
pub fn reactions(&self) -> PostsReactionsResource<'a> {
PostsReactionsResource { client: self.client }
}
/// `POST /posts`
///
/// Create a new post. Images must be uploaded previously in a separate request.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-posts");
/// let body = models::PostCreate {
/// content: Some("Hallo zusammen".into()),
/// title: "Hauskreis Nord".into(),
/// visibility: "group_intern".into(),
/// group_id: 42,
/// ..Default::default()
/// };
/// let result = client.posts().create(&body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::PostCreate) -> Result<models::Post> {
let path = "/posts".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// `DELETE /posts/{postId}`
///
/// Delete a post.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let query = DeletePostsPostIdQuery {
/// dry_run: Some(true),
/// ..Default::default()
/// };
/// client.posts().delete(42, &query)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, post_id: impl Display, query: &DeletePostsPostIdQuery) -> Result<()> {
let path = format!("/posts/{}", seg(post_id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// `GET /posts/{postId}`
///
/// Get a post.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-posts-postId");
/// let post = client.posts().get(42)?;
/// println!("{}", post.title);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, post_id: impl Display) -> Result<models::Post> {
self.get_with(post_id, &Default::default())
}
/// `GET /posts/{postId}`
///
/// Like [`Self::get`], with query parameters.
///
/// Get a post.
pub fn get_with(&self, post_id: impl Display, query: &GetPostsPostIdQuery) -> Result<models::Post> {
let path = format!("/posts/{}", seg(post_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// `GET /posts`
///
/// Get a list of posts sorted by `publishedDate` descending. This endpoint uses cursor-based pagination because the result can contain posts from external ChurchTools instances. To load another batch, use `before` together with `last_post_identifier`; page-based pagination is not supported.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-posts");
/// for post in client.posts().list()? {
/// println!("{}", post.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Post>> {
self.list_with(&Default::default())
}
/// `GET /posts`
///
/// Like [`Self::list`], with query parameters.
///
/// Get a list of posts sorted by `publishedDate` descending. This endpoint uses cursor-based pagination because the result can contain posts from external ChurchTools instances. To load another batch, use `before` together with `last_post_identifier`; page-based pagination is not supported.
pub fn list_with(&self, query: &GetPostsQuery) -> Result<Vec<models::Post>> {
let path = "/posts".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// `PATCH /posts/{postId}`
///
/// Update a post.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("patch-posts-postId");
/// let body = models::PostUpdate {
/// title: Some("Hauskreis Nord".into()),
/// ..Default::default()
/// };
/// let result = client.posts().patch(42, &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, post_id: impl Display, body: &models::PostUpdate) -> Result<models::Post> {
let path = format!("/posts/{}", seg(post_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
/// `PUT /posts/{postId}/expire`
///
/// Expire the referenced post immediately.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.posts().update_expire(42)?;
/// # Ok(())
/// # }
/// ```
pub fn update_expire(&self, post_id: impl Display) -> Result<()> {
let path = format!("/posts/{}/expire", seg(post_id));
let query: Query = Query::new();
self.client.request(Method::Put, &path, &query, None).map(|_| ())
}
}
/// `client.posts().comments()`
#[derive(Clone, Copy)]
pub struct PostsCommentsResource<'a> {
client: &'a Client,
}
impl<'a> PostsCommentsResource<'a> {
pub fn reactions(&self) -> PostsCommentsReactionsResource<'a> {
PostsCommentsReactionsResource { client: self.client }
}
/// `POST /posts/{postId}/comments`
///
/// Create a new comment for a post.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-posts-postId-comments");
/// let body = models::PostCommentCreate {
/// content: "Hallo zusammen".into(),
/// post_id: 42,
/// ..Default::default()
/// };
/// let result = client.posts().comments().create(42, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, post_id: impl Display, body: &models::PostCommentCreate) -> Result<models::PostComment> {
let path = format!("/posts/{}/comments", seg(post_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// `DELETE /posts/{postId}/comments/{commentId}`
///
/// Delete a comment of a post.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.posts().comments().delete(42, 42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, post_id: impl Display, comment_id: impl Display) -> Result<()> {
let path = format!("/posts/{}/comments/{}", seg(post_id), seg(comment_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// `GET /posts/{postId}/comments`
///
/// Get a list of comments for a post.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-posts-postId-comments");
/// for comment in client.posts().comments().list(42)? {
/// println!("{}", comment.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, post_id: impl Display) -> Result<Vec<models::PostComment>> {
let path = format!("/posts/{}/comments", seg(post_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.posts().comments().reactions()`
#[derive(Clone, Copy)]
pub struct PostsCommentsReactionsResource<'a> {
client: &'a Client,
}
impl<'a> PostsCommentsReactionsResource<'a> {
/// `DELETE /posts/{postId}/comments/{commentId}/reactions/{emoji}`
///
/// Delete a reaction of the current person for a post comment.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.posts().comments().reactions().delete(42, 42, "👍")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, post_id: impl Display, comment_id: impl Display, emoji: impl Display) -> Result<()> {
let path = format!("/posts/{}/comments/{}/reactions/{}", seg(post_id), seg(comment_id), seg(emoji));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// `GET /posts/{postId}/comments/{commentId}/reactions`
///
/// Get a list of reactions for a post comment.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-posts-postId-comments-commentId-reactions");
/// for reaction in client.posts().comments().reactions().list(42, 42)? {
/// println!("{}", reaction.comment_id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, post_id: impl Display, comment_id: impl Display) -> Result<Vec<models::PostCommentReaction>> {
let path = format!("/posts/{}/comments/{}/reactions", seg(post_id), seg(comment_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// `PUT /posts/{postId}/comments/{commentId}/reactions`
///
/// Create a new reaction of the current person for a post comment.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-posts-postId-comments-commentId-reactions");
/// let body = models::PostCommentReactionCreate {
/// emoji: "👍".into(),
/// ..Default::default()
/// };
/// let result = client.posts().comments().reactions().update(42, 42, &body)?;
/// println!("{}", result.comment_id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, post_id: impl Display, comment_id: impl Display, body: &models::PostCommentReactionCreate) -> Result<models::PostCommentReaction> {
let path = format!("/posts/{}/comments/{}/reactions", seg(post_id), seg(comment_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.posts().hidden()`
#[derive(Clone, Copy)]
pub struct PostsHiddenResource<'a> {
client: &'a Client,
}
impl<'a> PostsHiddenResource<'a> {
/// `PUT /posts/{postId}/hidden/{domainType}`
///
/// Hide a post. This endpoint is used to hide a post from the timeline of the user. The post is not deleted, but the user will not see it anymore. NB: If the supplied domain type is `group`, this will also deactivate post-related subscriptions for that group.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.posts().hidden().update(42, "actor")?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, post_id: impl Display, domain_type: impl Display) -> Result<()> {
let path = format!("/posts/{}/hidden/{}", seg(post_id), seg(domain_type));
let query: Query = Query::new();
self.client.request(Method::Put, &path, &query, None).map(|_| ())
}
}
/// `client.posts().reactions()`
#[derive(Clone, Copy)]
pub struct PostsReactionsResource<'a> {
client: &'a Client,
}
impl<'a> PostsReactionsResource<'a> {
pub fn persons(&self) -> PostsReactionsPersonsResource<'a> {
PostsReactionsPersonsResource { client: self.client }
}
/// `GET /posts/{postId}/reactions`
///
/// Get a list of reactions for a post.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-posts-postId-reactions");
/// for reaction in client.posts().reactions().list(42)? {
/// println!("{}", reaction.emoji);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, post_id: impl Display) -> Result<Vec<models::PostReaction>> {
let path = format!("/posts/{}/reactions", seg(post_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.posts().reactions().persons()`
#[derive(Clone, Copy)]
pub struct PostsReactionsPersonsResource<'a> {
client: &'a Client,
}
impl<'a> PostsReactionsPersonsResource<'a> {
/// `DELETE /posts/{postId}/reactions/{emoji}/persons/{personId}`
///
/// Delete a reaction of a person for a post.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.posts().reactions().persons().delete(42, "👍", "abc123")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, post_id: impl Display, emoji: impl Display, person_id: impl Display) -> Result<()> {
let path = format!("/posts/{}/reactions/{}/persons/{}", seg(post_id), seg(emoji), seg(person_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// `PUT /posts/{postId}/reactions/{emoji}/persons/{personId}`
///
/// Create a new reaction of a person for a post.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-posts-postId-reactions-emoji-persons-personId");
/// let result = client.posts().reactions().persons().update(42, "👍", "abc123")?;
/// println!("{}", result.emoji);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, post_id: impl Display, emoji: impl Display, person_id: impl Display) -> Result<models::PostReaction> {
let path = format!("/posts/{}/reactions/{}/persons/{}", seg(post_id), seg(emoji), seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Put, &path, &query, None)
}
}
/// `client.pr()`
#[derive(Clone, Copy)]
pub struct PrResource<'a> {
client: &'a Client,
}
impl<'a> PrResource<'a> {
/// Get public relations master data
///
/// `GET /pr/masterdata`
///
/// Returns the master data used by the public relations module and public profiles. The response groups each master data collection under `data` and returns the item count for each collection under `meta`.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-pr-masterdata");
/// let master_data = client.pr().get_master_data()?;
/// println!("{:?}", master_data);
/// # Ok(())
/// # }
/// ```
pub fn get_master_data(&self) -> Result<models::PublicRelationsMasterData> {
let path = "/pr/masterdata".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.printers()`
#[derive(Clone, Copy)]
pub struct PrintersResource<'a> {
client: &'a Client,
}
impl<'a> PrintersResource<'a> {
/// Get printers
///
/// `GET /printers`
///
/// Lists all configured check-in code printers, including inactive printers. active indicates whether a printer is enabled; the endpoint does not check online status or submit a print job. Requires authentication but no additional printer/check-in permission in this handler. Results have no pagination or guaranteed order, and meta.count is the number of returned printers.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-printers");
/// for printer in client.printers().list()? {
/// println!("{}", printer.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Printer>> {
let path = "/printers".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.probes()`
#[derive(Clone, Copy)]
pub struct ProbesResource<'a> {
client: &'a Client,
}
impl<'a> ProbesResource<'a> {
/// Get filtered probes
///
/// `POST /probes`
///
/// Returns probe definitions filtered by one or more domain types.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostProbesBody {
/// domain_type: vec!["person".into()],
/// ..Default::default()
/// };
/// for probe in client.probes().filter(&body)? {
/// println!("{}", probe.domain_type);
/// }
/// # Ok(())
/// # }
/// ```
pub fn filter(&self, body: &models::PostProbesBody) -> Result<Vec<models::Probe>> {
let path = "/probes".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.profiles()`
#[derive(Clone, Copy)]
pub struct ProfilesResource<'a> {
client: &'a Client,
}
impl<'a> ProfilesResource<'a> {
pub fn campuses(&self) -> ProfilesCampusesResource<'a> {
ProfilesCampusesResource { client: self.client }
}
pub fn slug_check(&self) -> ProfilesSlugCheckResource<'a> {
ProfilesSlugCheckResource { client: self.client }
}
/// Get a profile
///
/// `GET /profiles/church`
///
/// Get church profile information.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-profiles-church");
/// let church = client.profiles().get_church()?;
/// println!("{}", church.name);
/// # Ok(())
/// # }
/// ```
pub fn get_church(&self) -> Result<models::Profile> {
let path = "/profiles/church".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all profiles
///
/// `GET /profiles`
///
/// This endpoint returns all profiles for logged in users with permissions. All others (incl. public access) will only get published profiles.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-profiles");
/// for profile in client.profiles().list()? {
/// println!("{}", profile.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Profile>> {
let path = "/profiles".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update the church profile
///
/// `PUT /profiles/church`
///
/// Update church information
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ProfileUpdate {
/// name: "Hauskreis Nord".into(),
/// ..Default::default()
/// };
/// let result = client.profiles().update_church(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update_church(&self, body: &models::ProfileUpdate) -> Result<models::Profile> {
let path = "/profiles/church".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.profiles().campuses()`
#[derive(Clone, Copy)]
pub struct ProfilesCampusesResource<'a> {
client: &'a Client,
}
impl<'a> ProfilesCampusesResource<'a> {
/// Update a campus profile
///
/// `PUT /profiles/campuses/{id}`
///
/// Update campus profile information
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ProfileUpdate {
/// name: "Hauskreis Nord".into(),
/// ..Default::default()
/// };
/// let result = client.profiles().campuses().update(42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::ProfileUpdate) -> Result<models::Profile> {
let path = format!("/profiles/campuses/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.profiles().slug_check()`
#[derive(Clone, Copy)]
pub struct ProfilesSlugCheckResource<'a> {
client: &'a Client,
}
impl<'a> ProfilesSlugCheckResource<'a> {
/// Check if a finder slug is free
///
/// `GET /profiles/slugcheck/{slug}`
///
/// Published profiles are visibale in ChurchTools Finder. Each profile has an unique slug (URI). This endpoint can be used to check if a slug is free.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.profiles().slug_check().get("my-church")?;
/// # Ok(())
/// # }
/// ```
pub fn get(&self, slug: impl Display) -> Result<()> {
self.get_with(slug, &Default::default())
}
/// Check if a finder slug is free
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /profiles/slugcheck/{slug}`
///
/// Published profiles are visibale in ChurchTools Finder. Each profile has an unique slug (URI). This endpoint can be used to check if a slug is free.
pub fn get_with(&self, slug: impl Display, query: &GetProfilesSlugcheckSlugQuery) -> Result<()> {
let path = format!("/profiles/slugcheck/{}", seg(slug));
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
}
/// `client.public_groups()`
#[derive(Clone, Copy)]
pub struct PublicGroupsResource<'a> {
client: &'a Client,
}
impl<'a> PublicGroupsResource<'a> {
pub fn signup(&self) -> PublicGroupsSignupResource<'a> {
PublicGroupsSignupResource { client: self.client }
}
/// Get public group details
///
/// `GET /publicgroups/{groupId}`
///
/// Returns group details, signup conditions and eligible signUpPersons for the current user. Public access is supported, but normal group-view permission still applies. Optional hash restricts the lookup to an enabled group homepage. Without it, the group is loaded directly. Seat counts include membership/role rules and need not equal the number of persons. Image and leader fields depend on the homepage display settings; signUpConditions explains why a signup is currently available or unavailable.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-publicgroups-id");
/// let public_group = client.public_groups().get(42)?;
/// println!("{}", public_group.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, group_id: impl Display) -> Result<models::PublicGroupDetail> {
self.get_with(group_id, &Default::default())
}
/// Get public group details
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /publicgroups/{groupId}`
///
/// Returns group details, signup conditions and eligible signUpPersons for the current user. Public access is supported, but normal group-view permission still applies. Optional hash restricts the lookup to an enabled group homepage. Without it, the group is loaded directly. Seat counts include membership/role rules and need not equal the number of persons. Image and leader fields depend on the homepage display settings; signUpConditions explains why a signup is currently available or unavailable.
pub fn get_with(&self, group_id: impl Display, query: &GetPublicgroupsIdQuery) -> Result<models::PublicGroupDetail> {
let path = format!("/publicgroups/{}", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get group signup form
///
/// `GET /publicgroups/{groupId}/form`
///
/// Loads the dynamic signup form for a token belonging to this group. Requires access to group signup. The response is wrapped in data. Each field is identified by type plus id; required fields and allowed options depend on group configuration and on the requester. Additional spouse/child/other forms are null when unavailable. Optional personId selects the requester and persists that choice on the token (this GET changes state). Use a person returned by possiblerequesters. Prefilled person values and privacy state are returned in signUpPersons.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-publicgroups-groupId-form");
/// let query = GetPublicgroupsGroupIdFormQuery {
/// token: Some("abc123".into()),
/// ..Default::default()
/// };
/// let form = client.public_groups().get_form(42, &query)?;
/// println!("{:?}", form.email);
/// # Ok(())
/// # }
/// ```
pub fn get_form(&self, group_id: impl Display, query: &GetPublicgroupsGroupIdFormQuery) -> Result<models::PublicGroupFormResult> {
let path = format!("/publicgroups/{}/form", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List possible signup requesters
///
/// `GET /publicgroups/{groupId}/possiblerequesters`
///
/// Returns a requester-selection object for a token belonging to this group. Requires access to group signup. An email token lists persons sharing that address, because email addresses are not unique in ChurchTools; a token without email uses its requesterId. Status distinguishes existing members, pending/waiting requests and persons not yet requested. Results are not paginated and the DTO has no meta.count.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-publicgroups-groupId-possiblerequesters");
/// let query = GetPublicgroupsGroupIdPossiblerequestersQuery {
/// token: Some("abc123".into()),
/// ..Default::default()
/// };
/// let possible_requester = client.public_groups().get_possible_requesters(42, &query)?;
/// println!("{:?}", possible_requester.email);
/// # Ok(())
/// # }
/// ```
pub fn get_possible_requesters(&self, group_id: impl Display, query: &GetPublicgroupsGroupIdPossiblerequestersQuery) -> Result<models::PublicGroupPossibleRequesters> {
let path = format!("/publicgroups/{}/possiblerequesters", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get group withdrawal options
///
/// `GET /publicgroups/{groupId}/signoutdata`
///
/// Returns requester information and the persons whose group participation may be withdrawn directly or requires contacting leaders. A supplied signup token must belong to this group; without token the current user is used and signup access is required. For requesterId=-1 (no person created), requester and both person lists are null and noUserCreated=true is included. For a normal requester that flag is omitted. This GET does not withdraw anyone.
///
/// Use [`Self::get_signout_data_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-publicgroups-id-signoutdata");
/// let signout_data = client.public_groups().get_signout_data(42)?;
/// println!("{}", signout_data.group_has_auto_accept);
/// # Ok(())
/// # }
/// ```
pub fn get_signout_data(&self, group_id: impl Display) -> Result<models::PublicGroupSignoutData> {
self.get_signout_data_with(group_id, &Default::default())
}
/// Get group withdrawal options
///
/// Like [`Self::get_signout_data`], with query parameters.
///
/// `GET /publicgroups/{groupId}/signoutdata`
///
/// Returns requester information and the persons whose group participation may be withdrawn directly or requires contacting leaders. A supplied signup token must belong to this group; without token the current user is used and signup access is required. For requesterId=-1 (no person created), requester and both person lists are null and noUserCreated=true is included. For a normal requester that flag is omitted. This GET does not withdraw anyone.
pub fn get_signout_data_with(&self, group_id: impl Display, query: &GetPublicgroupsIdSignoutdataQuery) -> Result<models::PublicGroupSignoutData> {
let path = format!("/publicgroups/{}/signoutdata", seg(group_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get public group details
///
/// `GET /publicgroups/{groupId}/{hash}`
///
/// Returns group details, signup conditions and eligible signUpPersons for the current user. Public access is supported, but normal group-view permission still applies. The hash identifies an enabled group homepage; the group must be included in that homepage. This endpoint returns one group, not the whole homepage. Seat counts include membership/role rules and need not equal the number of persons. Image and leader fields depend on the homepage display settings; signUpConditions explains why a signup is currently available or unavailable.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-publicgroups-id-hash");
/// let with_hash = client.public_groups().get_with_hash(42, "abc123")?;
/// println!("{}", with_hash.name);
/// # Ok(())
/// # }
/// ```
pub fn get_with_hash(&self, group_id: impl Display, hash: impl Display) -> Result<models::PublicGroupDetail> {
let path = format!("/publicgroups/{}/{}", seg(group_id), seg(hash));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Contact public group leaders
///
/// `POST /publicgroups/{groupId}/mailToLeaders`
///
/// Sends the supplied message to group leaders with a default email address. Requires group signup access or a valid signup token for this group. The sender name/email are supplied by the caller. hideContactLeader is a display setting and is not checked here. No reachable leaders causes a server error; successful processing returns a message and does not create a membership.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PublicGroupLeaderMailCreate {
/// email: "mara@example.org".into(),
/// message: "Hallo zusammen".into(),
/// name: "Hauskreis Nord".into(),
/// ..Default::default()
/// };
/// let public_group = client.public_groups().mail_to_leaders(42, &body)?;
/// println!("{}", public_group.success);
/// # Ok(())
/// # }
/// ```
pub fn mail_to_leaders(&self, group_id: impl Display, body: &models::PublicGroupLeaderMailCreate) -> Result<models::PostPublicgroupsGroupIdMailToLeadersData> {
let path = format!("/publicgroups/{}/mailToLeaders", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Withdraw group registrations
///
/// `POST /publicgroups/{groupId}/signout`
///
/// Withdraws selected memberships for the requester or people registered by that requester. A group sign-up token identifies the requester without requiring a login; without a token the current user and group sign-up access are used. When registration is open, active, requested and waiting memberships are eligible. Otherwise the requester needs the group exit permission and only active memberships qualify. All person IDs are checked before changes begin. With automatic acceptance enabled, memberships are deleted; otherwise they are marked to_delete for approval and their role is cleared. The changes run in a transaction. An empty personIds list is a successful no-op. This signs people out of a group, not out of their ChurchTools session.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PublicGroupSignOutRequest {
/// person_ids: vec![42, 43],
/// ..Default::default()
/// };
/// client.public_groups().signout(42, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn signout(&self, group_id: impl Display, body: &models::PublicGroupSignOutRequest) -> Result<()> {
let path = format!("/publicgroups/{}/signout", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Submit group signup forms
///
/// `POST /publicgroups/{groupId}/signup`
///
/// Submits one form per person using a signup token for this group. Copy field type/id from the dynamic form and use its mandatory/options rules. Existing person IDs must be eligible for this requester; new spouse/child/other forms are available only when allowed by group settings. Adding related/other persons requires hasAcceptedPrivacyForOther=true. A child must be younger than 16. Membership may be accepted immediately, requested from leaders or placed on a waiting list; capacity is checked for the entire submitted set. Depending on group configuration, a new applicant may produce a request email instead of a new person. The operation is transactional for database changes. Success returns a top-level nullable groupHomepageHash, without a data wrapper.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PublicGroupSignupCreate {
/// forms: vec![models::PublicGroupSignupCreateFormsItem {
/// form: vec![models::PublicGroupSignupCreateFormsItemFormItem::default()],
/// ..Default::default()
/// }],
/// token: "abc123".into(),
/// ..Default::default()
/// };
/// let public_group = client.public_groups().submit_signup(42, &body)?;
/// println!("{:?}", public_group.group_homepage_hash);
/// # Ok(())
/// # }
/// ```
pub fn submit_signup(&self, group_id: impl Display, body: &models::PublicGroupSignupCreate) -> Result<models::PostPublicgroupsGroupIdSignupResponse> {
let path = format!("/publicgroups/{}/signup", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
/// Create group signup token
///
/// `POST /publicgroups/{groupId}/token`
///
/// Starts a group-membership signup, distinct from account self-registration. Requires access to this group’s signup and an open signup feature. In verification mode `all`, supply either the current logged-in personId for a token returned directly or an email address for a verification link. Another personId is forbidden, and personId and email are mutually exclusive. In modes `existing` and `none`, both may be omitted and a new-person token is returned directly; in mode `existing`, matching uses the email supplied later in the signup form. Email flow returns only a success message. Tokens can be used to load forms, select a requester and submit memberships; they have no stored expiry in the current implementation.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PublicGroupTokenCreate {
/// email: Some("mara@example.org".into()),
/// ..Default::default()
/// };
/// let result = client.public_groups().token(42, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn token(&self, group_id: impl Display, body: &models::PublicGroupTokenCreate) -> Result<serde_json::Value> {
let path = format!("/publicgroups/{}/token", seg(group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.public_groups().signup()`
#[derive(Clone, Copy)]
pub struct PublicGroupsSignupResource<'a> {
client: &'a Client,
}
impl<'a> PublicGroupsSignupResource<'a> {
pub fn confirm(&self) -> PublicGroupsSignupConfirmResource<'a> {
PublicGroupsSignupConfirmResource { client: self.client }
}
}
/// `client.public_groups().signup().confirm()`
#[derive(Clone, Copy)]
pub struct PublicGroupsSignupConfirmResource<'a> {
client: &'a Client,
}
impl<'a> PublicGroupsSignupConfirmResource<'a> {
/// Confirm a deferred public group signup
///
/// `POST /publicgroups/signup/confirm/{confirmationToken}`
///
/// Confirms a deferred group signup using the secret emailed to the requester. The link expires after 72 hours. Places are assigned using the group's current signup and waiting-list rules. Repeated confirmation is safe.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body: std::collections::BTreeMap<String, serde_json::Value> = Default::default();
/// let result = client.public_groups().signup().confirm().create("abc123", &body)?;
/// println!("{:?}", result.group_homepage_hash);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, confirmation_token: impl Display, body: &std::collections::BTreeMap<String, serde_json::Value>) -> Result<models::PostPublicgroupsSignupConfirmConfirmationTokenData> {
let path = format!("/publicgroups/signup/confirm/{}", seg(confirmation_token));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Show the deferred public group signup confirmation page
///
/// `GET /publicgroups/signup/confirm/{confirmationToken}`
///
/// Renders the deferred signup confirmation page without changing signup data. The page starts confirmation through the POST endpoint after JavaScript has loaded, preventing email link scanners from confirming the signup.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.public_groups().signup().confirm().get("abc123")?;
/// std::fs::write("ergebnis.bin", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get(&self, confirmation_token: impl Display) -> Result<Vec<u8>> {
let path = format!("/publicgroups/signup/confirm/{}", seg(confirmation_token));
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None)
}
}
/// `client.queues()`
#[derive(Clone, Copy)]
pub struct QueuesResource<'a> {
client: &'a Client,
}
impl<'a> QueuesResource<'a> {
pub fn job_groups(&self) -> QueuesJobGroupsResource<'a> {
QueuesJobGroupsResource { client: self.client }
}
/// Start Worker For Queue
///
/// `POST /queues/{queue}`
///
/// ChurchTools utilizes a queueing system to offload time-intensive or processing-intensive work. Calling this endpoint will start a worker, which grabs pending jobs and processing them. If the queue has still jobs pending the worker starts a new worker to continue the work.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let result = client.queues().create("default")?;
/// println!("{:?}", result.queue);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, queue: impl Display) -> Result<models::PostQueuesQueueData> {
let path = format!("/queues/{}", seg(queue));
let query: Query = Query::new();
self.client.request_data(Method::Post, &path, &query, None)
}
}
/// `client.queues().job_groups()`
#[derive(Clone, Copy)]
pub struct QueuesJobGroupsResource<'a> {
client: &'a Client,
}
impl<'a> QueuesJobGroupsResource<'a> {
/// Status Information About Job Groups in Queue
///
/// `GET /queues/{queue}/jobgroups/{jobGroup}`
///
/// Job in a queue can belong to a job group to categorize a job. This endpoint counts jobs in queue and groups them by they status.
///
/// Use this endpoint to check if all jobs are processed or if still jobs are pending and wait to be processed.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-queues-queue-jobgroups-jobGroup");
/// for job_group in client.queues().job_groups().get("beispiel", "beispiel")? {
/// println!("{}", job_group.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn get(&self, queue: impl Display, job_group: impl Display) -> Result<Vec<models::JobGroupStatus>> {
let path = format!("/queues/{}/jobgroups/{}", seg(queue), seg(job_group));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.registration_config()`
#[derive(Clone, Copy)]
pub struct RegistrationConfigResource<'a> {
client: &'a Client,
}
impl<'a> RegistrationConfigResource<'a> {
/// Get self-registration configuration
///
/// `GET /registrationconfig/{id}`
///
/// Loads the form and campus choices for self-registration. Callers with "churchcore administer persons" permission also receive administrative settings and audit metadata. `fields` contains active configured fields, or the default phone, address, sex and birthday fields when no selection is stored.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-registrationconfig-id");
/// let registration_config = client.registration_config().get(serde_json::json!(42))?;
/// println!("{}", registration_config.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::RegistrationConfig> {
let path = format!("/registrationconfig/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update self-registration configuration
///
/// `PATCH /registrationconfig/{id}`
///
/// Partially updates the numeric configuration ID. Requires "churchcore administer persons" permission. Supplied arrays replace their complete lists. Changing the configuration does not alter existing persons or memberships. Returns the complete administrative configuration.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RegistrationConfigUpdate {
/// is_active: Some(true),
/// ..Default::default()
/// };
/// let result = client.registration_config().patch(1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, id: impl Display, body: &models::RegistrationConfigUpdate) -> Result<models::RegistrationConfigAdmin> {
let path = format!("/registrationconfig/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
}
/// `client.registrations()`
#[derive(Clone, Copy)]
pub struct RegistrationsResource<'a> {
client: &'a Client,
}
impl<'a> RegistrationsResource<'a> {
/// Confirm self-registration email
///
/// `POST /registrations/{registrationGuid}/confirm`
///
/// Verifies the emailed token for an unconverted registration and records the confirmation time. Returns active persons with the same default email as `possibleMatches`, including configured form fields and `hasPassword`. Repeated confirmation is accepted while the registration is unconverted.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RegistrationConfirm {
/// token: "abc123".into(),
/// ..Default::default()
/// };
/// let registration = client.registrations().confirm("8c3bf5f0-305d-4e24-8e06-7c1d217fd3f1", &body)?;
/// println!("{}", registration.first_name);
/// # Ok(())
/// # }
/// ```
pub fn confirm(&self, registration_guid: impl Display, body: &models::RegistrationConfirm) -> Result<models::Registration> {
let path = format!("/registrations/{}/confirm", seg(registration_guid));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Complete self-registration
///
/// `POST /registrations/{registrationGuid}/convert`
///
/// Completes an email-confirmed, unconverted registration using its token. Creates a new person or links `personId` to an active person with the same default email. Requires an active/complete configuration and enabled default login. `formData` supplies consent and configured fields by field ID or modern person field name (ID takes precedence); unknown/unconfigured fields are discarded. Required configured fields and person data are validated. A new person receives configured status, departments, tags and campus group memberships; a sole campus is selected automatically, otherwise `formData.campusId` must match a configured campus. Existing persons receive supplied fields, configured existing-person tags and the registration password. Success marks conversion complete and logs in that person in the current session.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RegistrationConvert {
/// form_data: models::RegistrationConvertFormData {
/// accept_data_privacy: true,
/// ..Default::default()
/// },
/// token: "abc123".into(),
/// ..Default::default()
/// };
/// client.registrations().convert("8c3bf5f0-305d-4e24-8e06-7c1d217fd3f1", &body)?;
/// # Ok(())
/// # }
/// ```
pub fn convert(&self, registration_guid: impl Display, body: &models::RegistrationConvert) -> Result<()> {
let path = format!("/registrations/{}/convert", seg(registration_guid));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Start self-registration
///
/// `POST /registrations`
///
/// Starts account self-registration for the configuration GUID and emails a confirmation link. Requires an active, complete configuration and an enabled default login. Blacklisted email addresses, blocked accounts and recognized existing login accounts receive an informational email and return `204` without creating a registration.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RegistrationCreate {
/// config_id: "8c3bf5f0-305d-4e24-8e06-7c1d217fd3f1".into(),
/// email: "mara@example.org".into(),
/// first_name: "Mara".into(),
/// last_name: "Becker".into(),
/// password: "geheim".into(),
/// ..Default::default()
/// };
/// let result = client.registrations().create(&body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::RegistrationCreate) -> Result<Option<models::Registration>> {
let path = "/registrations".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete self-registration
///
/// `DELETE /registrations/{registrationGuid}`
///
/// Deletes the registration record by GUID. This does not delete a person created by an earlier conversion.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.registrations().delete("8c3bf5f0-305d-4e24-8e06-7c1d217fd3f1")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, registration_guid: impl Display) -> Result<()> {
let path = format!("/registrations/{}", seg(registration_guid));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Resend self-registration confirmation
///
/// `POST /registrations/{registrationGuid}/resend`
///
/// Resends the confirmation email for this registration.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.registrations().resend("8c3bf5f0-305d-4e24-8e06-7c1d217fd3f1")?;
/// # Ok(())
/// # }
/// ```
pub fn resend(&self, registration_guid: impl Display) -> Result<()> {
let path = format!("/registrations/{}/resend", seg(registration_guid));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
}
/// `client.repeat_calculation()`
#[derive(Clone, Copy)]
pub struct RepeatCalculationResource<'a> {
client: &'a Client,
}
impl<'a> RepeatCalculationResource<'a> {
/// Calculate occurrence dates without saving an appointment
///
/// `POST /repeatcalculation`
///
/// Calculates occurrence dates without storing an appointment.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-repeatcalculation");
/// let body = models::RepeatCalculationCreate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// ..Default::default()
/// };
/// for repeat_calculation in client.repeat_calculation().calculate(&body)? {
/// println!("{:?}", repeat_calculation);
/// }
/// # Ok(())
/// # }
/// ```
pub fn calculate(&self, body: &models::RepeatCalculationCreate) -> Result<Vec<models::RepeatCalculationOccurrence>> {
let path = "/repeatcalculation".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
/// Calculate occurrence dates without saving an appointment
///
/// `DELETE /repeatcalculation`
///
/// Calculates occurrence dates without storing an appointment. This is an alias of POST; use POST for new integrations.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RepeatCalculationCreate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// ..Default::default()
/// };
/// for repeat_calculation in client.repeat_calculation().delete(&body)? {
/// println!("{:?}", repeat_calculation);
/// }
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, body: &models::RepeatCalculationCreate) -> Result<Vec<models::RepeatCalculationOccurrence>> {
let path = "/repeatcalculation".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Delete, &path, &query, Some(&body))
}
/// Calculate occurrence dates without saving an appointment
///
/// `GET /repeatcalculation`
///
/// Calculates occurrence dates without storing an appointment. This is an alias of POST; use POST for new integrations.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-repeatcalculation");
/// let query = GetRepeatcalculationQuery {
/// end_date: Some(serde_json::json!("2026-09-20T09:30:00Z")),
/// start_date: Some(serde_json::json!("2026-09-20T08:00:00Z")),
/// ..Default::default()
/// };
/// for repeat_calculation in client.repeat_calculation().list(&query)? {
/// println!("{:?}", repeat_calculation);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetRepeatcalculationQuery) -> Result<Vec<models::RepeatCalculationOccurrence>> {
let path = "/repeatcalculation".to_owned();
let query: Query = query.to_query();
self.client.request_json(Method::Get, &path, &query, None)
}
/// Calculate occurrence dates without saving an appointment
///
/// `PATCH /repeatcalculation`
///
/// Calculates occurrence dates without storing an appointment. This is an alias of POST; use POST for new integrations.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RepeatCalculationCreate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// ..Default::default()
/// };
/// for repeat_calculation in client.repeat_calculation().patch(&body)? {
/// println!("{:?}", repeat_calculation);
/// }
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, body: &models::RepeatCalculationCreate) -> Result<Vec<models::RepeatCalculationOccurrence>> {
let path = "/repeatcalculation".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Patch, &path, &query, Some(&body))
}
/// Calculate occurrence dates without saving an appointment
///
/// `PUT /repeatcalculation`
///
/// Calculates occurrence dates without storing an appointment. This is an alias of POST; use POST for new integrations.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RepeatCalculationCreate {
/// end_date: DateOrDateTime::DateTime("2026-09-20T09:30:00Z".parse()?),
/// start_date: DateOrDateTime::DateTime("2026-09-20T08:00:00Z".parse()?),
/// ..Default::default()
/// };
/// for repeat_calculation in client.repeat_calculation().update(&body)? {
/// println!("{:?}", repeat_calculation);
/// }
/// # Ok(())
/// # }
/// ```
pub fn update(&self, body: &models::RepeatCalculationCreate) -> Result<Vec<models::RepeatCalculationOccurrence>> {
let path = "/repeatcalculation".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Put, &path, &query, Some(&body))
}
}
/// `client.reset_password()`
#[derive(Clone, Copy)]
pub struct ResetPasswordResource<'a> {
client: &'a Client,
}
impl<'a> ResetPasswordResource<'a> {
/// Request password reset
///
/// `POST /reset-password`
///
/// Requests password-reset emails for active, non-archived accounts matching the stored email address or login name. More than one account can match. The account must already have a password, a previous login or a stored invitation login token. Eligible accounts receive a reset link valid for two weeks. The response always contains a generic translated information message, including when no account matches; it does not reveal which accounts exist or confirm delivery. This public endpoint is rate-limited (normally 20 requests per 60 seconds; configurable through ratelimit.login). Opening a valid reset link creates a password-reset session; submit the new password through PUT /persons/{personId}/password.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PasswordResetCreate {
/// email_or_username: "alex@example.org".into(),
/// ..Default::default()
/// };
/// let result = client.reset_password().create(&body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::PasswordResetCreate) -> Result<models::PostResetPasswordData> {
let path = "/reset-password".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.resource()`
#[derive(Clone, Copy)]
pub struct ResourceResource<'a> {
client: &'a Client,
}
impl<'a> ResourceResource<'a> {
/// Get resource planning master data
///
/// `GET /resource/masterdata`
///
/// Returns all resource types ordered by `sortKey` and all resources visible to the current user. A resource is visible when the user has permission to view it or administer its bookings, or is listed in its `adminIds`. Resource types are not filtered, so some may have no visible resources. Use `include[]` to resolve resource administrators.
///
/// Use [`Self::get_master_data_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-resource-masterdata");
/// let master_data = client.resource().get_master_data()?;
/// println!("{:?}", master_data);
/// # Ok(())
/// # }
/// ```
pub fn get_master_data(&self) -> Result<models::ResourceMasterData> {
self.get_master_data_with(&Default::default())
}
/// Get resource planning master data
///
/// Like [`Self::get_master_data`], with query parameters.
///
/// `GET /resource/masterdata`
///
/// Returns all resource types ordered by `sortKey` and all resources visible to the current user. A resource is visible when the user has permission to view it or administer its bookings, or is listed in its `adminIds`. Resource types are not filtered, so some may have no visible resources. Use `include[]` to resolve resource administrators.
pub fn get_master_data_with(&self, query: &GetResourceMasterdataQuery) -> Result<models::ResourceMasterData> {
let path = "/resource/masterdata".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.resource_types()`
#[derive(Clone, Copy)]
pub struct ResourceTypesResource<'a> {
client: &'a Client,
}
impl<'a> ResourceTypesResource<'a> {
/// Create a resource type
///
/// `POST /resourcetypes`
///
/// Creates a category used to group resources. `campusId` optionally associates the type with an organizational campus.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-resourcetypes");
/// let body = models::ResourceTypeCreate {
/// name: "Room".into(),
/// name_plural: "Rooms".into(),
/// sort_key: 1,
/// ..Default::default()
/// };
/// let result = client.resource_types().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ResourceTypeCreate) -> Result<models::ResourceType> {
let path = "/resourcetypes".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a resource type
///
/// `DELETE /resourcetypes/{resourceTypeId}`
///
/// Deletes a resource category.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.resource_types().delete(2)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, resource_type_id: impl Display) -> Result<()> {
let path = format!("/resourcetypes/{}", seg(resource_type_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a resource type
///
/// `GET /resourcetypes/{resourceTypeId}`
///
/// Returns the resource category, its labels and optional campus assignment. It does not include the resources belonging to the type.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-resourcetypes-resourceTypeId");
/// let resource_type = client.resource_types().get(2)?;
/// println!("{}", resource_type.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, resource_type_id: impl Display) -> Result<models::ResourceType> {
let path = format!("/resourcetypes/{}", seg(resource_type_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List resource types
///
/// `GET /resourcetypes`
///
/// Returns all resource categories, such as rooms or vehicles, without filtering by resource visibility. A type may have no resources visible to the reader.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-resourcetypes");
/// for resource_type in client.resource_types().list()? {
/// println!("{}", resource_type.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::ResourceType>> {
let path = "/resourcetypes".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a resource type
///
/// `PUT /resourcetypes/{resourceTypeId}`
///
/// Replaces the resource category’s labels, sort value and campus assignment.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-resourcetypes-resourceTypeId");
/// let body = models::ResourceTypeUpdate {
/// name: "Room".into(),
/// name_plural: "Rooms".into(),
/// sort_key: 1,
/// ..Default::default()
/// };
/// let result = client.resource_types().update(2, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, resource_type_id: impl Display, body: &models::ResourceTypeUpdate) -> Result<models::ResourceType> {
let path = format!("/resourcetypes/{}", seg(resource_type_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.resources()`
#[derive(Clone, Copy)]
pub struct ResourcesResource<'a> {
client: &'a Client,
}
impl<'a> ResourcesResource<'a> {
/// Create a resource
///
/// `POST /resources`
///
/// Creates an individual bookable resource. Returns 402 when the licensed resource limit is reached.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-resources");
/// let body = models::ResourceCreate {
/// name: "Main Hall".into(),
/// resource_type_id: 2,
/// sort_key: 1,
/// ..Default::default()
/// };
/// let result = client.resources().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ResourceCreate) -> Result<models::Resource> {
let path = "/resources".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a resource
///
/// `DELETE /resources/{resourceId}`
///
/// Deletes the resource.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.resources().delete(7)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, resource_id: impl Display) -> Result<()> {
let path = format!("/resources/{}", seg(resource_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a resource
///
/// `GET /resources/{resourceId}`
///
/// Returns one resource and its booking settings. A resource is visible when the user has permission to view it or administer its bookings, or is listed in its `adminIds`. Use `include[]` to resolve administrators.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-resources-resourceId");
/// let resource = client.resources().get(7)?;
/// println!("{}", resource.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, resource_id: impl Display) -> Result<models::Resource> {
self.get_with(resource_id, &Default::default())
}
/// Get a resource
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /resources/{resourceId}`
///
/// Returns one resource and its booking settings. A resource is visible when the user has permission to view it or administer its bookings, or is listed in its `adminIds`. Use `include[]` to resolve administrators.
pub fn get_with(&self, resource_id: impl Display, query: &GetResourcesResourceIdQuery) -> Result<models::Resource> {
let path = format!("/resources/{}", seg(resource_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Count pending booking occurrences
///
/// `GET /resources/{resourceId}/statistics`
///
/// Returns the number of pending booking occurrences from now onward for this resource. Recurring bookings can contribute more than one occurrence. Candidate series are selected using a ten-year lookahead window, then expanded from now without an upper date limit. A resource is visible when the user has permission to view it or administer its bookings, or is listed in its `adminIds`.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-resources-resourceId-statistics");
/// let statistic = client.resources().get_statistics(7)?;
/// println!("{}", statistic.num_requested_bookings_in_future);
/// # Ok(())
/// # }
/// ```
pub fn get_statistics(&self, resource_id: impl Display) -> Result<models::ResourceStatistics> {
let path = format!("/resources/{}/statistics", seg(resource_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List visible resources
///
/// `GET /resources`
///
/// Returns all resources visible to the current user. A resource is visible when the user has permission to view it or administer its bookings, or is listed in its `adminIds`. Use `include[]` to resolve administrators.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-resources");
/// for resource in client.resources().list()? {
/// println!("{}", resource.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Resource>> {
self.list_with(&Default::default())
}
/// List visible resources
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /resources`
///
/// Returns all resources visible to the current user. A resource is visible when the user has permission to view it or administer its bookings, or is listed in its `adminIds`. Use `include[]` to resolve administrators.
pub fn list_with(&self, query: &GetResourcesQuery) -> Result<Vec<models::Resource>> {
let path = "/resources".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a resource
///
/// `PUT /resources/{resourceId}`
///
/// Replaces the resource configuration.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-resources-resourceId");
/// let body = models::ResourceUpdate {
/// name: "Main Hall".into(),
/// resource_type_id: 2,
/// sort_key: 1,
/// ..Default::default()
/// };
/// let result = client.resources().update(7, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, resource_id: impl Display, body: &models::ResourceUpdate) -> Result<models::Resource> {
let path = format!("/resources/{}", seg(resource_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.routines()`
#[derive(Clone, Copy)]
pub struct RoutinesResource<'a> {
client: &'a Client,
}
impl<'a> RoutinesResource<'a> {
pub fn runs(&self) -> RoutinesRunsResource<'a> {
RoutinesRunsResource { client: self.client }
}
pub fn steps(&self) -> RoutinesStepsResource<'a> {
RoutinesStepsResource { client: self.client }
}
/// Create group-membership automation
///
/// `POST /routines`
///
/// Creates a routine and attaches it to a group, role and optional membership status. Currently domainType must be group_membership. Requires routine administration for the context group. The new definition has no steps; use PATCH to add the complete step tree. isEnabled defaults to false and priority to 0. Creation alone does not explicitly start the worker.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RoutineCreate {
/// domain_context: models::RoutineCreateDomainContext {
/// group_id: 42,
/// group_type_role_id: 42,
/// ..Default::default()
/// },
/// domain_type: "group_membership".into(),
/// name: "Welcome new members".into(),
/// ..Default::default()
/// };
/// let result = client.routines().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::RoutineCreate) -> Result<models::Routine> {
let path = "/routines".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete automation definition
///
/// `DELETE /routines/{routineId}`
///
/// Requires routine administration for every associated group. Deletes the routine, its steps and associated action definitions through action cleanup handlers. A missing routine returns 404. This endpoint has no dry-run. Effects already produced by previous runs, such as sent mail or person changes, are not reversed.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.routines().delete(9)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, routine_id: impl Display) -> Result<()> {
let path = format!("/routines/{}", seg(routine_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Process pending automation runs
///
/// `POST /routines/execute`
///
/// Triggers the shared routine worker for pending ready runs of enabled routines. Requires authentication; this controller has no additional routine/group authorization check. Processes batches of up to 25 runs and schedules another worker when a batch is full. A recent worker marker or ongoing bulk processing can skip execution while still returning 204. This is a global processing trigger, not a request to execute one selected routine or a completion report.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.routines().execute()?;
/// # Ok(())
/// # }
/// ```
pub fn execute(&self) -> Result<()> {
let path = "/routines/execute".to_owned();
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Get automation definition
///
/// `GET /routines/{routineId}`
///
/// Requires routine administration for every associated group. Returns the definition and nested step tree, including disabled steps. A routine with no associated domain context is not visible through this endpoint. Action data is expanded for clients, including stored email/follow-up definitions. Run progress is available separately from /runs.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-routines-routineId");
/// let routine = client.routines().get(9)?;
/// println!("{}", routine.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, routine_id: impl Display) -> Result<models::Routine> {
let path = format!("/routines/{}", seg(routine_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List visible automation definitions
///
/// `GET /routines`
///
/// A routine is an automation definition attached to a domain context (currently a group membership role/status). Each matching membership can have its own run and progress. Lists only routines with at least one domain attachment for which the caller can administer routines in every associated group. Includes enabled and disabled definitions with nested step trees; no pagination or explicit sort order. meta.count counts the returned routines.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-routines");
/// for routine in client.routines().list()? {
/// println!("{}", routine.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Routine>> {
self.list_with(&Default::default())
}
/// List visible automation definitions
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /routines`
///
/// A routine is an automation definition attached to a domain context (currently a group membership role/status). Each matching membership can have its own run and progress. Lists only routines with at least one domain attachment for which the caller can administer routines in every associated group. Includes enabled and disabled definitions with nested step trees; no pagination or explicit sort order. meta.count counts the returned routines.
pub fn list_with(&self, query: &GetRoutinesQuery) -> Result<Vec<models::Routine>> {
let path = "/routines".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update automation and reposition runs
///
/// `PATCH /routines/{routineId}`
///
/// Requires routine administration for every associated group. Partially updates definition fields. Supplied steps replaces the entire step tree: keep id to update an existing step, omit id to create one; an existing step’s actionKey cannot change. Omitted steps are deleted, but affected runs must be repositioned or the operation returns 422. restart/finish and per-step reposition accept source step IDs or not-started/started/finished run buckets. Repeat loops may occur only at root level, must contain a waiting action, and an unbounded loop must be last. Destructive membership actions must be last. dry_run=true validates input and permissions, returns 204 and skips persistence; persistence-only consistency checks can still fail on the real update. Enabling, changing steps or repositioning runs can immediately trigger pending execution beyond this routine.
///
/// Use [`Self::patch_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RoutineUpdate {
/// name: Some("Welcome new members".into()),
/// ..Default::default()
/// };
/// let result = client.routines().patch(9, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, routine_id: impl Display, body: &models::RoutineUpdate) -> Result<Option<models::Routine>> {
self.patch_with(routine_id, &Default::default(), body)
}
/// Update automation and reposition runs
///
/// Like [`Self::patch`], with query parameters.
///
/// `PATCH /routines/{routineId}`
///
/// Requires routine administration for every associated group. Partially updates definition fields. Supplied steps replaces the entire step tree: keep id to update an existing step, omit id to create one; an existing step’s actionKey cannot change. Omitted steps are deleted, but affected runs must be repositioned or the operation returns 422. restart/finish and per-step reposition accept source step IDs or not-started/started/finished run buckets. Repeat loops may occur only at root level, must contain a waiting action, and an unbounded loop must be last. Destructive membership actions must be last. dry_run=true validates input and permissions, returns 204 and skips persistence; persistence-only consistency checks can still fail on the real update. Enabling, changing steps or repositioning runs can immediately trigger pending execution beyond this routine.
pub fn patch_with(&self, routine_id: impl Display, query: &PatchRoutinesRoutineIdQuery, body: &models::RoutineUpdate) -> Result<Option<models::Routine>> {
let path = format!("/routines/{}", seg(routine_id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
}
/// `client.routines().runs()`
#[derive(Clone, Copy)]
pub struct RoutinesRunsResource<'a> {
client: &'a Client,
}
impl<'a> RoutinesRunsResource<'a> {
pub fn bulk(&self) -> RoutinesRunsBulkResource<'a> {
RoutinesRunsBulkResource { client: self.client }
}
/// Apply action to an automation run
///
/// `POST /routines/{routineId}/runs/{runId}/{runAction}`
///
/// Requires routine administration for every associated group. Actions pause, resume, restart-routine, restart-step, skip-step and update change run state and then invoke the worker, so the returned status may already reflect further execution. For update, supply at most one of currentIteration and waitingSince. currentIteration=0 is ignored by the current implementation; other integers have no minimum constraint. waitingSince is stored as a calendar date. A state change incompatible with the current step can return 422. Use run IDs belonging to the route routine; the current backend authorizes routineId separately from the run lookup.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RoutineRunUpdate {
/// current_iteration: Some(42),
/// ..Default::default()
/// };
/// let result = client.routines().runs().create(9, 16, "pause", &body)?;
/// println!("{:?}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, routine_id: impl Display, run_id: impl Display, run_action: impl Display, body: &models::RoutineRunUpdate) -> Result<models::RoutineRun> {
let path = format!("/routines/{}/runs/{}/{}", seg(routine_id), seg(run_id), seg(run_action));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// List automation runs and potential runs
///
/// `GET /routines/{routineId}/runs`
///
/// Requires routine administration for every associated group. Lists persisted runs with isReady=true for this routine. with_potential_domain_objects=true appends eligible memberships without a run as not-started entries with id=null and meta=null; these are previews, not newly persisted runs. No pagination or explicit ordering. include\[\]=domainObject adds the resolved membership domain object or null if it cannot be resolved. Loop iteration and wait-start date are included only when available; terminal runs omit them.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-routines-routineId-runs");
/// for run in client.routines().runs().list(9)? {
/// println!("{:?}", run.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, routine_id: impl Display) -> Result<Vec<models::RoutineRun>> {
self.list_with(routine_id, &Default::default())
}
/// List automation runs and potential runs
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /routines/{routineId}/runs`
///
/// Requires routine administration for every associated group. Lists persisted runs with isReady=true for this routine. with_potential_domain_objects=true appends eligible memberships without a run as not-started entries with id=null and meta=null; these are previews, not newly persisted runs. No pagination or explicit ordering. include\[\]=domainObject adds the resolved membership domain object or null if it cannot be resolved. Loop iteration and wait-start date are included only when available; terminal runs omit them.
pub fn list_with(&self, routine_id: impl Display, query: &GetRoutinesRoutineIdRunsQuery) -> Result<Vec<models::RoutineRun>> {
let path = format!("/routines/{}/runs", seg(routine_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.routines().runs().bulk()`
#[derive(Clone, Copy)]
pub struct RoutinesRunsBulkResource<'a> {
client: &'a Client,
}
impl<'a> RoutinesRunsBulkResource<'a> {
/// Apply action to multiple automation runs
///
/// `POST /routines/{routineId}/runs/bulk/{runAction}`
///
/// Requires routine administration for every associated group. Actions pause, resume, restart-routine, restart-step, skip-step and update change run state and then invoke the worker, so the returned status may already reflect further execution. runIds is a nonempty list. Each run is processed in a separate transaction; earlier runs may remain changed when a later one fails. The bulk endpoint validates no currentIteration/waitingSince fields, so update cannot change those values here. Use run IDs belonging to the route routine; the current backend authorizes routineId separately from the run lookup.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RoutineRunBulkUpdate {
/// run_ids: vec![42],
/// ..Default::default()
/// };
/// for bulk in client.routines().runs().bulk().create(9, "pause", &body)? {
/// println!("{:?}", bulk.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn create(&self, routine_id: impl Display, run_action: impl Display, body: &models::RoutineRunBulkUpdate) -> Result<Vec<models::RoutineRun>> {
let path = format!("/routines/{}/runs/bulk/{}", seg(routine_id), seg(run_action));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.routines().steps()`
#[derive(Clone, Copy)]
pub struct RoutinesStepsResource<'a> {
client: &'a Client,
}
impl<'a> RoutinesStepsResource<'a> {
/// Validate one automation action
///
/// `POST /routines/{routineId}/steps/validate`
///
/// Requires routine administration for every associated group. Validates actionKey/actionData and checks action execution permission in the routine context without creating or executing a step. For special:repeat, count is optional (unbounded) and otherwise at least 1. special:wait requires exactly one of untilDate or duration, with at least one positive numDays/numMonths/numYears. This endpoint does not validate a complete step tree, nesting, ordering or whether a repeat loop includes a delay; PATCH applies those checks separately. Unknown action keys currently produce a server error.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::RoutineActionValidation {
/// action_key: "special:wait".into(),
/// ..Default::default()
/// };
/// client.routines().steps().validate(42, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn validate(&self, routine_id: impl Display, body: &models::RoutineActionValidation) -> Result<()> {
let path = format!("/routines/{}/steps/validate", seg(routine_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.saml()`
#[derive(Clone, Copy)]
pub struct SamlResource<'a> {
client: &'a Client,
}
impl<'a> SamlResource<'a> {
/// Consume a SAML authentication response
///
/// `POST /saml/acs`
///
/// Legacy SAML URL. Resolves the single configured SAML provider; with zero or multiple SAML providers it cannot resolve a provider. Prefer the provider-specific /externallogins/{externalLoginId}/saml/acs URL. Public assertion-consumer callback for the identity provider’s form POST. Validates the SAML response and maps the external identity to a ChurchTools person. Successful login redirects to the stored destination or the installation landing page; identities needing account linking are redirected into that flow instead. Normal login requires a visible provider. Administrator test flows can use hidden providers and return a small HTML page that closes the popup, without logging the tested identity in. Test failures can also return that 200 HTML page: read the separate test-result endpoint for the outcome. A pending administrator test with missing RelayState also returns the popup page. Normal failures return 401 as localized text or an HTML error page, never the usual JSON error envelope.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.saml().acs()?;
/// std::fs::write("ergebnis.bin", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn acs(&self) -> Result<Vec<u8>> {
let path = "/saml/acs".to_owned();
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None)
}
/// Start a SAML browser login
///
/// `GET /saml/login`
///
/// Legacy SAML URL. Resolves the single configured SAML provider; with zero or multiple SAML providers it cannot resolve a provider. Prefer the provider-specific /externallogins/{externalLoginId}/saml/login URL. Starts the browser-based SAML login for a visible SAML external-login provider. Redirects to the configured identity provider with a SAML authentication request and an opaque RelayState. An optional post-login redirect is saved in the browser session, so the callback must retain that session. Only absolute URLs on this installation’s origin and within its base path are accepted; invalid redirect values are ignored. Missing, hidden or invalid providers and other setup failures produce a localized 404 response. No login or JSON access token is returned by this endpoint itself.
///
/// Use [`Self::get_login_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.saml().get_login()?;
/// # Ok(())
/// # }
/// ```
pub fn get_login(&self) -> Result<()> {
self.get_login_with(&Default::default())
}
/// Start a SAML browser login
///
/// Like [`Self::get_login`], with query parameters.
///
/// `GET /saml/login`
///
/// Legacy SAML URL. Resolves the single configured SAML provider; with zero or multiple SAML providers it cannot resolve a provider. Prefer the provider-specific /externallogins/{externalLoginId}/saml/login URL. Starts the browser-based SAML login for a visible SAML external-login provider. Redirects to the configured identity provider with a SAML authentication request and an opaque RelayState. An optional post-login redirect is saved in the browser session, so the callback must retain that session. Only absolute URLs on this installation’s origin and within its base path are accepted; invalid redirect values are ignored. Missing, hidden or invalid providers and other setup failures produce a localized 404 response. No login or JSON access token is returned by this endpoint itself.
pub fn get_login_with(&self, query: &GetSamlLoginQuery) -> Result<()> {
let path = "/saml/login".to_owned();
let query: Query = query.to_query();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
/// Get SAML service-provider metadata
///
/// `GET /saml/metadata`
///
/// Legacy SAML URL. Resolves the single configured SAML provider; with zero or multiple SAML providers it cannot resolve a provider. Prefer the provider-specific /externallogins/{externalLoginId}/saml/metadata URL. Returns the XML metadata that an identity-provider administrator uses to configure ChurchTools as a SAML service provider. The entity ID, assertion-consumer URL and logout URL refer to this external-login provider. This endpoint is public and also works for a hidden provider, allowing setup before enabling login. Any provider/configuration/metadata-generation failure is returned as 404 with localized text, not a JSON error envelope.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let data = client.saml().get_metadata()?;
/// std::fs::write("ergebnis.bin", &data)?;
/// # Ok(())
/// # }
/// ```
pub fn get_metadata(&self) -> Result<Vec<u8>> {
let path = "/saml/metadata".to_owned();
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None)
}
}
/// `client.search()`
#[derive(Clone, Copy)]
pub struct SearchResource<'a> {
client: &'a Client,
}
impl<'a> SearchResource<'a> {
/// Global Search
///
/// `GET /search`
///
/// Search globally for different or all domain types.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-search");
/// let query = GetSearchQuery {
/// query: Some("max".into()),
/// ..Default::default()
/// };
/// for search in client.search().list(&query)? {
/// println!("{}", search.r#type);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, query: &GetSearchQuery) -> Result<Vec<models::GetSearchDataItem>> {
let path = "/search".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.security_levels()`
#[derive(Clone, Copy)]
pub struct SecurityLevelsResource<'a> {
client: &'a Client,
}
impl<'a> SecurityLevelsResource<'a> {
/// Create a new security Level
///
/// `POST /securitylevels/{id}`
///
/// Create a new Security level
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostSecuritylevelsIdBody {
/// name: Some("Hauskreis Nord".into()),
/// ..Default::default()
/// };
/// let result = client.security_levels().create(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, id: impl Display, body: &models::PostSecuritylevelsIdBody) -> Result<models::PostSecuritylevelsIdResponse> {
let path = format!("/securitylevels/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
/// Delete the Security Level
///
/// `DELETE /securitylevels/{id}`
///
/// Delete a security level
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.security_levels().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete the Security Level
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /securitylevels/{id}`
///
/// Delete a security level
pub fn delete_with(&self, id: impl Display, query: &DeleteSecuritylevelsIdQuery) -> Result<()> {
let path = format!("/securitylevels/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a particular security level
///
/// `GET /securitylevels/{id}`
///
/// Get a particular Security Level
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-securitylevels-id");
/// let security_level = client.security_levels().get(1)?;
/// println!("{}", security_level.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::SecurityLevel> {
let path = format!("/securitylevels/{}", seg(id));
let query: Query = Query::new();
self.client.request_json(Method::Get, &path, &query, None)
}
/// get all securitylevels
///
/// `GET /securitylevels`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-securitylevels");
/// for security_level in client.security_levels().list()? {
/// println!("{}", security_level.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::SecurityLevel>> {
let path = "/securitylevels".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update the security level
///
/// `PATCH /securitylevels/{id}`
///
/// Change the Security Level
///
/// Use [`Self::patch_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PatchSecuritylevelsIdBody {
/// name: Some("Hauskreis Nord".into()),
/// ..Default::default()
/// };
/// let result = client.security_levels().patch(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, id: impl Display, body: &models::PatchSecuritylevelsIdBody) -> Result<models::PatchSecuritylevelsIdResponse> {
self.patch_with(id, &Default::default(), body)
}
/// Update the security level
///
/// Like [`Self::patch`], with query parameters.
///
/// `PATCH /securitylevels/{id}`
///
/// Change the Security Level
pub fn patch_with(&self, id: impl Display, query: &PatchSecuritylevelsIdQuery, body: &models::PatchSecuritylevelsIdBody) -> Result<models::PatchSecuritylevelsIdResponse> {
let path = format!("/securitylevels/{}", seg(id));
let query: Query = query.to_query();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Patch, &path, &query, Some(&body))
}
}
/// `client.service_groups()`
#[derive(Clone, Copy)]
pub struct ServiceGroupsResource<'a> {
client: &'a Client,
}
impl<'a> ServiceGroupsResource<'a> {
/// Create a service group
///
/// `POST /servicegroups`
///
/// Creates a reusable service group master-data record. Requires the "edit masterdata" permission for the service planning domain.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-servicegroups");
/// let body = models::ServiceGroupCreate {
/// name: "Hauskreis Nord".into(),
/// ..Default::default()
/// };
/// let result = client.service_groups().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ServiceGroupCreate) -> Result<models::ServiceGroup> {
let path = "/servicegroups".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a service group
///
/// `DELETE /servicegroups/{serviceGroupId}`
///
/// Deletes the service group master-data record through the dependency-aware deletion service. A dependency conflict returns `409`. Requires the "edit masterdata" permission for the service planning domain.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.service_groups().delete(13)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, service_group_id: impl Display) -> Result<()> {
let path = format!("/servicegroups/{}", seg(service_group_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a service group
///
/// `GET /servicegroups/{serviceGroupId}`
///
/// Returns the reusable service group master-data record with the specified ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-servicegroups-id");
/// let service_group = client.service_groups().get(13)?;
/// println!("{}", service_group.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, service_group_id: impl Display) -> Result<models::ServiceGroup> {
let path = format!("/servicegroups/{}", seg(service_group_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all service groups
///
/// `GET /servicegroups`
///
/// Returns all service groups as an unpaginated list, sorted by `sortKey` and then name, both ascending.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-servicegroups");
/// for service_group in client.service_groups().list()? {
/// println!("{}", service_group.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::ServiceGroup>> {
let path = "/servicegroups".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a service group
///
/// `PUT /servicegroups/{serviceGroupId}`
///
/// Requires the "edit masterdata" permission for the service planning domain.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-servicegroups-id");
/// let body = models::ServiceGroupUpdate {
/// name: "Hauskreis Nord".into(),
/// ..Default::default()
/// };
/// let result = client.service_groups().update(13, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, service_group_id: impl Display, body: &models::ServiceGroupUpdate) -> Result<models::ServiceGroup> {
let path = format!("/servicegroups/{}", seg(service_group_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.services()`
#[derive(Clone, Copy)]
pub struct ServicesResource<'a> {
client: &'a Client,
}
impl<'a> ServicesResource<'a> {
/// Create a service
///
/// `POST /services`
///
/// Creates a reusable service master-data record. Requires the "edit masterdata" permission for the service planning domain.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-services");
/// let body = models::ServiceCreate {
/// name: "Hauskreis Nord".into(),
/// service_group_id: 42,
/// ..Default::default()
/// };
/// let result = client.services().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ServiceCreate) -> Result<models::Service> {
let path = "/services".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a service
///
/// `DELETE /services/{serviceId}`
///
/// Deletes the service master-data record through the dependency-aware deletion service. A dependency conflict returns `409`. Requires the "edit masterdata" permission for the service planning domain.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.services().delete(2)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, service_id: impl Display) -> Result<()> {
let path = format!("/services/{}", seg(service_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a service
///
/// `GET /services/{serviceId}`
///
/// Returns the reusable service master-data record with the specified ID.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-services-id");
/// let service = client.services().get(2)?;
/// println!("{}", service.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, service_id: impl Display) -> Result<models::Service> {
let path = format!("/services/{}", seg(service_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all services
///
/// `GET /services`
///
/// Returns all services as an unpaginated list, sorted by `sortKey` and then name, both ascending.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-services");
/// for service in client.services().list()? {
/// println!("{}", service.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Service>> {
let path = "/services".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a service
///
/// `PUT /services/{serviceId}`
///
/// Update a service role. Requires the "edit masterdata" permission for the service planning domain.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-services-id");
/// let body = models::ServiceUpdate {
/// name: "Hauskreis Nord".into(),
/// service_group_id: 42,
/// ..Default::default()
/// };
/// let result = client.services().update(2, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, service_id: impl Display, body: &models::ServiceUpdate) -> Result<models::Service> {
let path = format!("/services/{}", seg(service_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.simulate()`
#[derive(Clone, Copy)]
pub struct SimulateResource<'a> {
client: &'a Client,
}
impl<'a> SimulateResource<'a> {
/// Start person simulation
///
/// `POST /simulate`
///
/// Starts simulating another person. The current user's session will act as the specified person until the simulation is stopped.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PostSimulateBody {
/// person_id: 42,
/// ..Default::default()
/// };
/// client.simulate().create(&body)?;
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::PostSimulateBody) -> Result<()> {
let path = "/simulate".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Stop person simulation
///
/// `DELETE /simulate`
///
/// Stops the current person simulation and returns a redirect path to navigate back.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let simulate = client.simulate().delete()?;
/// println!("{}", simulate.redirect);
/// # Ok(())
/// # }
/// ```
pub fn delete(&self) -> Result<models::DeleteSimulateData> {
let path = "/simulate".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Delete, &path, &query, None)
}
}
/// `client.song()`
#[derive(Clone, Copy)]
pub struct SongResource<'a> {
client: &'a Client,
}
impl<'a> SongResource<'a> {
pub fn categories(&self) -> SongCategoriesResource<'a> {
SongCategoriesResource { client: self.client }
}
pub fn sources(&self) -> SongSourcesResource<'a> {
SongSourcesResource { client: self.client }
}
}
/// `client.song().categories()`
#[derive(Clone, Copy)]
pub struct SongCategoriesResource<'a> {
client: &'a Client,
}
impl<'a> SongCategoriesResource<'a> {
/// Create a song category
///
/// `POST /song/categories`
///
/// Creates a song category. Requires `edit masterdata` in churchservice. A supplied campus ID must exist.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-song-categories");
/// let body = models::SongCategoryCreate {
/// name: "Worship".into(),
/// ..Default::default()
/// };
/// let result = client.song().categories().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::SongCategoryCreate) -> Result<models::SongCategory> {
let path = "/song/categories".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete song category
///
/// `DELETE /song/categories/{songCategoryId}`
///
/// Deletes the song category. Requires `edit masterdata` in churchservice. Songs referencing this category prevent deletion.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.song().categories().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, song_category_id: impl Display) -> Result<()> {
let path = format!("/song/categories/{}", seg(song_category_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a song category by ID
///
/// `GET /song/categories/{songCategoryId}`
///
/// Returns one song category without an additional record-level visibility check.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-song-categories-id");
/// let category = client.song().categories().get(1)?;
/// println!("{}", category.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, song_category_id: impl Display) -> Result<models::SongCategory> {
let path = format!("/song/categories/{}", seg(song_category_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all song categories
///
/// `GET /song/categories`
///
/// Returns all song categories ordered by sortKey ascending and then name ascending. The list is unpaginated and has no visibility or campus filter.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-song-categories");
/// for category in client.song().categories().list()? {
/// println!("{}", category.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::SongCategory>> {
let path = "/song/categories".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update song category
///
/// `PUT /song/categories/{songCategoryId}`
///
/// Replaces the song category. Requires `edit masterdata` in churchservice. A supplied campus ID must exist.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-song-categories-id");
/// let body = models::SongCategoryUpdate {
/// name: "Worship".into(),
/// ..Default::default()
/// };
/// let result = client.song().categories().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, song_category_id: impl Display, body: &models::SongCategoryUpdate) -> Result<models::SongCategory> {
let path = format!("/song/categories/{}", seg(song_category_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.song().sources()`
#[derive(Clone, Copy)]
pub struct SongSourcesResource<'a> {
client: &'a Client,
}
impl<'a> SongSourcesResource<'a> {
/// Create a song source
///
/// `POST /song/sources`
///
/// Creates a song source. Requires `edit masterdata` in churchservice.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-song-sources");
/// let body = models::SongSourceCreate {
/// name: "Community hymnal".into(),
/// ..Default::default()
/// };
/// let result = client.song().sources().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::SongSourceCreate) -> Result<models::SongSource> {
let path = "/song/sources".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete song source
///
/// `DELETE /song/sources/{songSourceId}`
///
/// Deletes the song source. Requires `edit masterdata` in churchservice. Arrangements referencing this source prevent deletion.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.song().sources().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, song_source_id: impl Display) -> Result<()> {
let path = format!("/song/sources/{}", seg(song_source_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get song source by ID
///
/// `GET /song/sources/{songSourceId}`
///
/// Returns one song source without an additional record-level visibility check.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-song-sources-id");
/// let source = client.song().sources().get(1)?;
/// println!("{}", source.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, song_source_id: impl Display) -> Result<models::SongSource> {
let path = format!("/song/sources/{}", seg(song_source_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all song sources
///
/// `GET /song/sources`
///
/// Returns all song sources ordered by sortKey ascending and then name ascending. The list is unpaginated and has no visibility or campus filter.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-song-sources");
/// for source in client.song().sources().list()? {
/// println!("{}", source.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::SongSource>> {
let path = "/song/sources".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update song source
///
/// `PUT /song/sources/{songSourceId}`
///
/// Replaces the song source. Requires `edit masterdata` in churchservice.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-song-sources-id");
/// let body = models::SongSourceUpdate {
/// name: "Community hymnal".into(),
/// ..Default::default()
/// };
/// let result = client.song().sources().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, song_source_id: impl Display, body: &models::SongSourceUpdate) -> Result<models::SongSource> {
let path = format!("/song/sources/{}", seg(song_source_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.songs()`
#[derive(Clone, Copy)]
pub struct SongsResource<'a> {
client: &'a Client,
}
impl<'a> SongsResource<'a> {
pub fn arrangements(&self) -> SongsArrangementsResource<'a> {
SongsArrangementsResource { client: self.client }
}
/// Create a new song
///
/// `POST /songs`
///
/// Creates a song in an existing category. Requires edit songcategory permission for that category. Inline arrangements use the same contract as the arrangement creation endpoint, including source and file assignments. The first arrangement becomes the default unless a later item requests that role. The response does not enrich tags.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-songs");
/// let body = models::SongCreate {
/// category_id: 1,
/// name: "Hallelujah".into(),
/// ..Default::default()
/// };
/// let result = client.songs().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::SongCreate) -> Result<models::Song> {
let path = "/songs".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete song
///
/// `DELETE /songs/{songId}`
///
/// Deletes the song, its tag associations, arrangements and arrangement files. The tags themselves remain available. Requires edit songcategory permission for the song's category. Agenda items referring to deleted arrangements keep their item records but lose the arrangement reference.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.songs().delete(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, song_id: impl Display) -> Result<()> {
let path = format!("/songs/{}", seg(song_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get song
///
/// `GET /songs/{songId}`
///
/// Returns a song with its category, musical details and all arrangements. Requires view songcategory or edit songcategory permission for its category. Use include=tags to additionally retrieve its tags. Arrangement selection for a particular event belongs to that event's agenda item.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-songs-songId");
/// let song = client.songs().get(42)?;
/// println!("{}", song.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, song_id: impl Display) -> Result<models::Song> {
self.get_with(song_id, &Default::default())
}
/// Get song
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /songs/{songId}`
///
/// Returns a song with its category, musical details and all arrangements. Requires view songcategory or edit songcategory permission for its category. Use include=tags to additionally retrieve its tags. Arrangement selection for a particular event belongs to that event's agenda item.
pub fn get_with(&self, song_id: impl Display, query: &GetSongsSongIdQuery) -> Result<models::Song> {
let path = format!("/songs/{}", seg(song_id));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all songs
///
/// `GET /songs`
///
/// Returns songs in categories for which the caller has view songcategory or edit songcategory permission. Songs are sorted by name, then ID, both ascending. Filters are combined with AND; query matches either title or author. Category filters are intersected with permitted categories. No permitted or matching songs returns an empty list. Each song includes all arrangements, including those that do not match key_of_arrangement. Results are paginated.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-songs");
/// for song in client.songs().list()? {
/// println!("{}", song.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Song>> {
self.list_with(&Default::default())
}
/// Get all songs
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /songs`
///
/// Returns songs in categories for which the caller has view songcategory or edit songcategory permission. Songs are sorted by name, then ID, both ascending. Filters are combined with AND; query matches either title or author. Category filters are intersected with permitted categories. No permitted or matching songs returns an empty list. Each song includes all arrangements, including those that do not match key_of_arrangement. Results are paginated.
pub fn list_with(&self, query: &GetSongsQuery) -> Result<Vec<models::Song>> {
let path = "/songs".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// Get all songs
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetSongsQuery) -> Items<models::Song> {
let path = "/songs".to_owned();
self.client.items(&path, query.to_query())
}
/// Update song
///
/// `PUT /songs/{songId}`
///
/// Replaces the song's main details. Requires "edit songcategory" permission for both the current and requested category. When supplied, tags replace all current tag associations. Arrangements are not processed. The response is not enriched with tags.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-songs-songId");
/// let body = models::SongUpdate {
/// category_id: 1,
/// name: "Hallelujah".into(),
/// ..Default::default()
/// };
/// let result = client.songs().update(42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, song_id: impl Display, body: &models::SongUpdate) -> Result<models::Song> {
let path = format!("/songs/{}", seg(song_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.songs().arrangements()`
#[derive(Clone, Copy)]
pub struct SongsArrangementsResource<'a> {
client: &'a Client,
}
impl<'a> SongsArrangementsResource<'a> {
pub fn files(&self) -> SongsArrangementsFilesResource<'a> {
SongsArrangementsFilesResource { client: self.client }
}
/// Create new arrangement for song
///
/// `POST /songs/{songId}/arrangements`
///
/// Creates a musical version of an existing song. Requires edit songcategory permission for the song's category. Existing files can be assigned with fileIds. The first arrangement becomes the default; otherwise `isDefault: true` replaces the current default.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-songs-songId-arrangements");
/// let body = models::ArrangementCreate {
/// name: "Men Voicing".into(),
/// ..Default::default()
/// };
/// let result = client.songs().arrangements().create(42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, song_id: impl Display, body: &models::ArrangementCreate) -> Result<models::Arrangement> {
let path = format!("/songs/{}/arrangements", seg(song_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete arrangement
///
/// `DELETE /songs/{songId}/arrangements/{arrangementId}`
///
/// Deletes an arrangement belonging to this song and its attached files and links. Requires edit songcategory permission for the song's category. When arrangements remain, one is selected as the default and agenda items referring to the deleted arrangement are reassigned to it.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.songs().arrangements().delete(42, 42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, song_id: impl Display, arrangement_id: impl Display) -> Result<()> {
let path = format!("/songs/{}/arrangements/{}", seg(song_id), seg(arrangement_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get arrangement of song
///
/// `GET /songs/{songId}/arrangements/{arrangementId}`
///
/// Returns one arrangement with its musical details, source, files and links. Requires view songcategory or edit songcategory permission for the song's category. The arrangement must belong to the song in the path.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-songs-songId-arrangements-arrangementId");
/// let arrangement = client.songs().arrangements().get(42, 42)?;
/// println!("{}", arrangement.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, song_id: impl Display, arrangement_id: impl Display) -> Result<models::Arrangement> {
let path = format!("/songs/{}/arrangements/{}", seg(song_id), seg(arrangement_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get arrangements of song
///
/// `GET /songs/{songId}/arrangements`
///
/// Returns every arrangement belonging to the song, including each arrangement's files and links. An arrangement is a musical version with its own key, tempo and source. The list is unpaginated, has no guaranteed order and includes meta.count. Requires view songcategory or edit songcategory permission for the song's category.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-songs-songId-arrangements");
/// for arrangement in client.songs().arrangements().list(42)? {
/// println!("{}", arrangement.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, song_id: impl Display) -> Result<Vec<models::Arrangement>> {
let path = format!("/songs/{}/arrangements", seg(song_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Make arrangement the default
///
/// `PATCH /songs/{songId}/arrangements/{arrangementId}/default`
///
/// Makes this arrangement the only default for the song by clearing the default flag on all of the song's other arrangements. Requires edit songcategory permission for the song's category. The arrangement must belong to this song. No request body is needed. Selecting an arrangement that is already the default also returns 204.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.songs().arrangements().patch_default(42, 42)?;
/// # Ok(())
/// # }
/// ```
pub fn patch_default(&self, song_id: impl Display, arrangement_id: impl Display) -> Result<()> {
let path = format!("/songs/{}/arrangements/{}/default", seg(song_id), seg(arrangement_id));
let query: Query = Query::new();
self.client.request(Method::Patch, &path, &query, None).map(|_| ())
}
/// Update arrangement of song
///
/// `PUT /songs/{songId}/arrangements/{arrangementId}`
///
/// Replaces the musical details of an arrangement belonging to this song. Requires edit songcategory permission for the song's category. Files and links are unchanged. To change the default arrangement, use the dedicated default endpoint; isDefault is not processed here.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-songs-songId-arrangements-arrangementId");
/// let body = models::ArrangementUpdate {
/// name: "Men Voicing".into(),
/// ..Default::default()
/// };
/// let result = client.songs().arrangements().update(42, 42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, song_id: impl Display, arrangement_id: impl Display, body: &models::ArrangementUpdate) -> Result<models::Arrangement> {
let path = format!("/songs/{}/arrangements/{}", seg(song_id), seg(arrangement_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.songs().arrangements().files()`
#[derive(Clone, Copy)]
pub struct SongsArrangementsFilesResource<'a> {
client: &'a Client,
}
impl<'a> SongsArrangementsFilesResource<'a> {
/// Create a transposed arrangement audio file
///
/// `POST /songs/{songId}/arrangements/{arrangementId}/files/{fileId}/transpose`
///
/// Transposes an existing audio file by one to six semitones and saves a new file on the arrangement identified by arrangementId. The original file is retained. Processing is synchronous, so the response is sent after conversion and saving finish. Pitch is changed with tempo compensation to preserve the playback duration. The output retains the source filename extension and contains audio only. Supported formats depend on the server's FFmpeg installation; an unsupported or unreadable input causes an error. Each successful call creates a new file record. This does not update the arrangement's key or tempo metadata. Requires view permission for churchservice and edit permission for the source file; for song arrangement files, this is edit songcategory permission for the source song's category.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ArrangementFileTransposeCreate {
/// transpose_interval: "up2".into(),
/// ..Default::default()
/// };
/// let file = client.songs().arrangements().files().transpose(42, 42, 42, &body)?;
/// println!("{}", file.id);
/// # Ok(())
/// # }
/// ```
pub fn transpose(&self, song_id: impl Display, arrangement_id: impl Display, file_id: impl Display, body: &models::ArrangementFileTransposeCreate) -> Result<models::ArrangementFileTranspose> {
let path = format!("/songs/{}/arrangements/{}/files/{}/transpose", seg(song_id), seg(arrangement_id), seg(file_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_json(Method::Post, &path, &query, Some(&body))
}
}
/// `client.sso_logins()`
#[derive(Clone, Copy)]
pub struct SsoLoginsResource<'a> {
client: &'a Client,
}
impl<'a> SsoLoginsResource<'a> {
/// List visible single sign-on providers
///
/// `GET /sso-logins`
///
/// Returns visible external login providers that have a registered handler and login link. This public list is intended for the login screen and does not expose provider credentials or configuration. Providers are returned without pagination or a guaranteed order. Hidden providers are omitted. primaryLogin and hasRegistration are presentation/configuration flags, not a guarantee that an external login or account creation will succeed.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sso-logins");
/// for sso_login in client.sso_logins().list()? {
/// println!("{}", sso_login.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::SsoLogin>> {
let path = "/sso-logins".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.start_page()`
#[derive(Clone, Copy)]
pub struct StartPageResource<'a> {
client: &'a Client,
}
impl<'a> StartPageResource<'a> {
/// Widgets and data for startpage
///
/// `GET /startpage`
///
/// Here you get data like birthdays in the next seven days, open meeting requests, next appointments and songs to lern
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-startpage");
/// for start_page in client.start_page().list()? {
/// println!("{:?}", start_page);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<serde_json::Value>> {
let path = "/startpage".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.statuses()`
#[derive(Clone, Copy)]
pub struct StatusesResource<'a> {
client: &'a Client,
}
impl<'a> StatusesResource<'a> {
/// Save new status
///
/// `POST /statuses`
///
/// Creates a person-status definition. Requires "edit masterdata" permission in `churchdb`.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-statuses");
/// let body = models::StatusCreate {
/// name: "Member".into(),
/// security_level_id: 2,
/// ..Default::default()
/// };
/// let result = client.statuses().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::StatusCreate) -> Result<models::Status> {
let path = "/statuses".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a status
///
/// `DELETE /statuses/{id}`
///
/// Deletes the status definition after checking dependent references. Requires "edit masterdata" permission in `churchdb`. Person assignments and other configuration can block deletion.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.statuses().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
let path = format!("/statuses/{}", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a specific status
///
/// `GET /statuses/{id}`
///
/// Returns one person-status definition, including its translated name and abbreviation.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-statuses-id");
/// let status = client.statuses().get(1)?;
/// println!("{}", status.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::Status> {
let path = format!("/statuses/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all statuses
///
/// `GET /statuses`
///
/// Returns all person-status definitions, ordered by `sortKey` and then name.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-statuses");
/// for status in client.statuses().list()? {
/// println!("{}", status.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::Status>> {
let path = "/statuses".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update status
///
/// `PATCH /statuses/{id}`
///
/// Updates the supplied fields of the specified person-status definition. Requires "edit masterdata" permission in `churchdb`. Omitted fields remain unchanged.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("patch-statuses-id");
/// let body = models::StatusUpdate {
/// name: Some("Member".into()),
/// ..Default::default()
/// };
/// let result = client.statuses().patch(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, id: impl Display, body: &models::StatusUpdate) -> Result<models::Status> {
let path = format!("/statuses/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
/// Update status
///
/// `PUT /statuses/{id}`
///
/// Replaces a person-status definition. Requires "edit masterdata" permission in `churchdb`. Existing persons retain the status ID. Use `PATCH /statuses/{id}` instead.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-statuses-id");
/// let body = models::StatusCreate {
/// name: "Member".into(),
/// security_level_id: 2,
/// ..Default::default()
/// };
/// let result = client.statuses().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
#[deprecated = "PUT /statuses/{id} is deprecated in the ChurchTools API. Use `PATCH /statuses/{id}` instead."]
pub fn update(&self, id: impl Display, body: &models::StatusCreate) -> Result<models::Status> {
let path = format!("/statuses/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.subscriptions()`
#[derive(Clone, Copy)]
pub struct SubscriptionsResource<'a> {
client: &'a Client,
}
impl<'a> SubscriptionsResource<'a> {
/// Delete an explicit subscription override
///
/// `DELETE /subscriptions/{personId}/{subject}/{subjectIdentifier}`
///
/// Subscriptions control notifications for a subject (for example a group, post or resource). Explicit settings override implicit defaults for the same person, subject and identifier. Only the current person may access their own subscriptions. Removes the stored override, not the implicit default. If no explicit row exists, returns 404 even when GET returns an implicit subscription. Removing an inactive override can enable notifications again through the default; use PUT with isActive=false to opt out. Legacy subjects meetingrequests and servicerequests are normalized to meetingrequest and servicerequest; identifier 0 is normalized to root for both. List responses additionally include a legacy alias for each canonical root result. These aliases are compatibility copies, not separate subscriptions.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.subscriptions().delete(42, "group", "root")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, person_id: impl Display, subject: impl Display, subject_identifier: impl Display) -> Result<()> {
let path = format!("/subscriptions/{}/{}/{}", seg(person_id), seg(subject), seg(subject_identifier));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get one effective subscription
///
/// `GET /subscriptions/{personId}/{subject}/{subjectIdentifier}`
///
/// Subscriptions control notifications for a subject (for example a group, post or resource). Explicit settings override implicit defaults for the same person, subject and identifier. Only the current person may access their own subscriptions. Read results include active and inactive subscriptions, after subject-specific eligibility filtering: meeting/service requests require a registered push-capable device, email summaries require an eligible recipient, and resources require administration or booking-administration rights. A stored override can therefore be absent from a read response. Legacy subjects meetingrequests and servicerequests are normalized to meetingrequest and servicerequest; identifier 0 is normalized to root for both. List responses additionally include a legacy alias for each canonical root result. These aliases are compatibility copies, not separate subscriptions. This endpoint returns one object using the canonical subject and identifier, without a compatibility copy. It returns 404 when no eligible effective subscription exists and 422 if more than one result remains.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-subscriptions-personId-subject-subjectIdentifier");
/// let result = client.subscriptions().get(42, "group", "root")?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, person_id: impl Display, subject: impl Display, subject_identifier: impl Display) -> Result<serde_json::Value> {
let path = format!("/subscriptions/{}/{}/{}", seg(person_id), seg(subject), seg(subject_identifier));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List the current person’s effective subscriptions
///
/// `GET /subscriptions/{personId}`
///
/// Subscriptions control notifications for a subject (for example a group, post or resource). Explicit settings override implicit defaults for the same person, subject and identifier. Only the current person may access their own subscriptions. Read results include active and inactive subscriptions, after subject-specific eligibility filtering: meeting/service requests require a registered push-capable device, email summaries require an eligible recipient, and resources require administration or booking-administration rights. A stored override can therefore be absent from a read response. Results are not paginated; meta.count includes compatibility aliases. Legacy subjects meetingrequests and servicerequests are normalized to meetingrequest and servicerequest; identifier 0 is normalized to root for both. List responses additionally include a legacy alias for each canonical root result. These aliases are compatibility copies, not separate subscriptions.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-subscriptions-personId");
/// for subscription in client.subscriptions().list(42)? {
/// println!("{:?}", subscription);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, person_id: impl Display) -> Result<Vec<serde_json::Value>> {
let path = format!("/subscriptions/{}", seg(person_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List effective subscriptions for one subject
///
/// `GET /subscriptions/{personId}/{subject}`
///
/// Subscriptions control notifications for a subject (for example a group, post or resource). Explicit settings override implicit defaults for the same person, subject and identifier. Only the current person may access their own subscriptions. Read results include active and inactive subscriptions, after subject-specific eligibility filtering: meeting/service requests require a registered push-capable device, email summaries require an eligible recipient, and resources require administration or booking-administration rights. A stored override can therefore be absent from a read response. Results are not paginated; meta.count includes compatibility aliases. Legacy subjects meetingrequests and servicerequests are normalized to meetingrequest and servicerequest; identifier 0 is normalized to root for both. List responses additionally include a legacy alias for each canonical root result. These aliases are compatibility copies, not separate subscriptions.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-subscriptions-personId-subject");
/// for for_subject in client.subscriptions().list_for_subject(42, "group")? {
/// println!("{:?}", for_subject);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_for_subject(&self, person_id: impl Display, subject: impl Display) -> Result<Vec<serde_json::Value>> {
let path = format!("/subscriptions/{}/{}", seg(person_id), seg(subject));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Create or replace an explicit subscription override
///
/// `PUT /subscriptions/{personId}/{subject}/{subjectIdentifier}`
///
/// Subscriptions control notifications for a subject (for example a group, post or resource). Explicit settings override implicit defaults for the same person, subject and identifier. Only the current person may access their own subscriptions. Creates or updates a stored override and returns that single object before read-side eligibility filtering. Omitted isActive becomes true and omitted options clears existing options to null. For post_summary, options.filter and 1–7 distinct options.weekdays are required, and the current person needs a receiving email address. Use identifier 0 for post_summary. Legacy subjects meetingrequests and servicerequests are normalized to meetingrequest and servicerequest; identifier 0 is normalized to root for both. List responses additionally include a legacy alias for each canonical root result. These aliases are compatibility copies, not separate subscriptions.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SubscriptionUpdate {
/// is_active: Some(true),
/// ..Default::default()
/// };
/// let result = client.subscriptions().update(42, "group", "root", &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, person_id: impl Display, subject: impl Display, subject_identifier: impl Display, body: &models::SubscriptionUpdate) -> Result<serde_json::Value> {
let path = format!("/subscriptions/{}/{}/{}", seg(person_id), seg(subject), seg(subject_identifier));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.sync()`
#[derive(Clone, Copy)]
pub struct SyncResource<'a> {
client: &'a Client,
}
impl<'a> SyncResource<'a> {
pub fn adapters(&self) -> SyncAdaptersResource<'a> {
SyncAdaptersResource { client: self.client }
}
pub fn conflicts(&self) -> SyncConflictsResource<'a> {
SyncConflictsResource { client: self.client }
}
pub fn entity_mappings(&self) -> SyncEntityMappingsResource<'a> {
SyncEntityMappingsResource { client: self.client }
}
pub fn externalsystems(&self) -> SyncExternalsystemsResource<'a> {
SyncExternalsystemsResource { client: self.client }
}
/// Store sync log entries
///
/// `POST /sync/logs`
///
/// Stores log entries. `messageKey`, translation arguments and changes are rendered into a stored message.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncLogsCreate {
/// logs: vec![models::SyncLogCreate {
/// date: "2022-10-19T12:00:00Z".parse()?,
/// execution_id: "abc123".into(),
/// job_id: 42,
/// level: "debug".into(),
/// message_key: "Hallo zusammen".into(),
/// r#type: "create".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.sync().create_logs(&body)?;
/// println!("{}", result.persisted);
/// # Ok(())
/// # }
/// ```
pub fn create_logs(&self, body: &models::SyncLogsCreate) -> Result<models::SyncLogsPersisted> {
let path = "/sync/logs".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// List sync execution summaries
///
/// `GET /sync/executions`
///
/// Returns background executions ordered by creation date descending and job ID ascending. Counts are derived from operation logs.
///
/// Use [`Self::list_executions_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-executions");
/// for execution in client.sync().list_executions()? {
/// println!("{:?}", execution.created_date);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_executions(&self) -> Result<Vec<models::SyncExecutionSummary>> {
self.list_executions_with(&Default::default())
}
/// List sync execution summaries
///
/// Like [`Self::list_executions`], with query parameters.
///
/// `GET /sync/executions`
///
/// Returns background executions ordered by creation date descending and job ID ascending. Counts are derived from operation logs.
pub fn list_executions_with(&self, query: &GetSyncExecutionsQuery) -> Result<Vec<models::SyncExecutionSummary>> {
let path = "/sync/executions".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List sync execution summaries
///
/// Like [`Self::list_executions_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_executions_iter(&self, query: &GetSyncExecutionsQuery) -> Items<models::SyncExecutionSummary> {
let path = "/sync/executions".to_owned();
self.client.items(&path, query.to_query())
}
/// List sync job configurations
///
/// `GET /sync/jobconfigs`
///
/// Lists job configurations ordered by name.
///
/// Use [`Self::list_job_configs_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-jobconfigs");
/// for job_config in client.sync().list_job_configs()? {
/// println!("{}", job_config.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_job_configs(&self) -> Result<Vec<models::JobConfigurationReturn>> {
self.list_job_configs_with(&Default::default())
}
/// List sync job configurations
///
/// Like [`Self::list_job_configs`], with query parameters.
///
/// `GET /sync/jobconfigs`
///
/// Lists job configurations ordered by name.
pub fn list_job_configs_with(&self, query: &GetSyncJobconfigsQuery) -> Result<Vec<models::JobConfigurationReturn>> {
let path = "/sync/jobconfigs".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List sync log entries
///
/// `GET /sync/logs`
///
/// Returns rendered log messages ordered by log ID descending.
///
/// Use [`Self::list_logs_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-logs");
/// for log in client.sync().list_logs()? {
/// println!("{}", log.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_logs(&self) -> Result<Vec<models::SyncLog>> {
self.list_logs_with(&Default::default())
}
/// List sync log entries
///
/// Like [`Self::list_logs`], with query parameters.
///
/// `GET /sync/logs`
///
/// Returns rendered log messages ordered by log ID descending.
pub fn list_logs_with(&self, query: &GetSyncLogsQuery) -> Result<Vec<models::SyncLog>> {
let path = "/sync/logs".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List sync log entries
///
/// Like [`Self::list_logs_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_logs_iter(&self, query: &GetSyncLogsQuery) -> Items<models::SyncLog> {
let path = "/sync/logs".to_owned();
self.client.items(&path, query.to_query())
}
}
/// `client.sync().adapters()`
#[derive(Clone, Copy)]
pub struct SyncAdaptersResource<'a> {
client: &'a Client,
}
impl<'a> SyncAdaptersResource<'a> {
pub fn proxy(&self) -> SyncAdaptersProxyResource<'a> {
SyncAdaptersProxyResource { client: self.client }
}
/// Register a sync adapter
///
/// `POST /sync/adapters`
///
/// Registers the service URL and authentication token of an adapter. Registration does not configure an external connection.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncAdapterCreate {
/// name: "churchtools".into(),
/// token: "kfghsjdlkfigblszurglizeifuz4".into(),
/// url: "http://localhost:8090".into(),
/// ..Default::default()
/// };
/// let result = client.sync().adapters().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::SyncAdapterCreate) -> Result<models::SyncAdapter> {
let path = "/sync/adapters".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a sync adapter
///
/// `DELETE /sync/adapters/{id}`
///
/// Deletes the adapter registration. External connections referencing it block deletion.
///
/// Use [`Self::delete_with`] to pass query parameters.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().adapters().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
self.delete_with(id, &Default::default())
}
/// Delete a sync adapter
///
/// Like [`Self::delete`], with query parameters.
///
/// `DELETE /sync/adapters/{id}`
///
/// Deletes the adapter registration. External connections referencing it block deletion.
pub fn delete_with(&self, id: impl Display, query: &DeleteSyncAdaptersIdQuery) -> Result<()> {
let path = format!("/sync/adapters/{}", seg(id));
let query: Query = query.to_query();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a sync adapter
///
/// `GET /sync/adapters/{id}`
///
/// Returns adapter settings with a masked token.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-adapters-id");
/// let adapter = client.sync().adapters().get(1)?;
/// println!("{}", adapter.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::SyncAdapter> {
let path = format!("/sync/adapters/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List sync adapters
///
/// `GET /sync/adapters`
///
/// Lists registered adapter services. An adapter translates between the Sync worker and a system-specific API.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-adapters");
/// for adapter in client.sync().adapters().list()? {
/// println!("{}", adapter.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::SyncAdapter>> {
let path = "/sync/adapters".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Replace sync adapter settings
///
/// `PUT /sync/adapters/{id}`
///
/// Replaces the adapter name, URL and authentication token.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncAdapterUpdate {
/// name: "churchtools".into(),
/// token: "kfghsjdlkfigblszurglizeifuz4".into(),
/// url: "http://localhost:8090".into(),
/// ..Default::default()
/// };
/// let result = client.sync().adapters().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::SyncAdapterUpdate) -> Result<models::SyncAdapter> {
let path = format!("/sync/adapters/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.sync().adapters().proxy()`
#[derive(Clone, Copy)]
pub struct SyncAdaptersProxyResource<'a> {
client: &'a Client,
}
impl<'a> SyncAdaptersProxyResource<'a> {
/// Proxy POST to a sync adapter
///
/// `POST /sync/adapters/{adapterName}/proxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. Uses the registered adapter token.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().adapters().proxy().create("churchtools", "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn create(&self, adapter_name: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/adapters/{}/proxy/{}", seg(adapter_name), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Proxy DELETE to a sync adapter
///
/// `DELETE /sync/adapters/{adapterName}/proxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. Uses the registered adapter token.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().adapters().proxy().delete("churchtools", "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, adapter_name: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/adapters/{}/proxy/{}", seg(adapter_name), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Proxy GET to a sync adapter
///
/// `GET /sync/adapters/{adapterName}/proxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. Uses the registered adapter token.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().adapters().proxy().get("churchtools", "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn get(&self, adapter_name: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/adapters/{}/proxy/{}", seg(adapter_name), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
/// Proxy PATCH to a sync adapter
///
/// `PATCH /sync/adapters/{adapterName}/proxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. Uses the registered adapter token.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().adapters().proxy().patch("churchtools", "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, adapter_name: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/adapters/{}/proxy/{}", seg(adapter_name), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Patch, &path, &query, None).map(|_| ())
}
/// Proxy PUT to a sync adapter
///
/// `PUT /sync/adapters/{adapterName}/proxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. Uses the registered adapter token.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().adapters().proxy().update("churchtools", "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, adapter_name: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/adapters/{}/proxy/{}", seg(adapter_name), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Put, &path, &query, None).map(|_| ())
}
}
/// `client.sync().conflicts()`
#[derive(Clone, Copy)]
pub struct SyncConflictsResource<'a> {
client: &'a Client,
}
impl<'a> SyncConflictsResource<'a> {
/// Record a sync conflict
///
/// `POST /sync/conflicts`
///
/// Creates a conflict record. Requires "churchcore: administer persons" permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncConflictCreate {
/// data: vec![models::SyncConflictDataCreate {
/// key: "abc123".into(),
/// value: "beispiel".into(),
/// ..Default::default()
/// }],
/// entity_mapping_id: 1,
/// job_id: "7e31c399-91b1-4148-bfdd-6c05b557a25c".into(),
/// r#type: "create".into(),
/// ..Default::default()
/// };
/// let result = client.sync().conflicts().create(&body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::SyncConflictCreate) -> Result<models::SyncConflicts> {
let path = "/sync/conflicts".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a sync conflict
///
/// `DELETE /sync/conflicts/{id}`
///
/// Removes the conflict record without resolving or modifying the underlying records. Missing conflicts also return `204`. Requires "churchcore: administer persons" permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().conflicts().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
let path = format!("/sync/conflicts/{}", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a sync conflict
///
/// `GET /sync/conflicts/{id}`
///
/// Returns one conflict and its supporting key/value data. Requires "churchcore: administer persons" permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let conflict = client.sync().conflicts().get(1)?;
/// println!("{}", conflict.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::SyncConflicts> {
let path = format!("/sync/conflicts/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List sync conflicts
///
/// `GET /sync/conflicts`
///
/// Filters on source and domain refer to the linked entity mapping. Conflict `jobId` identifies the producing sync run, not a job configuration. Requires "churchcore: administer persons" permission.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-conflicts");
/// for conflict in client.sync().conflicts().list()? {
/// println!("{}", conflict.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::SyncConflicts>> {
self.list_with(&Default::default())
}
/// List sync conflicts
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /sync/conflicts`
///
/// Filters on source and domain refer to the linked entity mapping. Conflict `jobId` identifies the producing sync run, not a job configuration. Requires "churchcore: administer persons" permission.
pub fn list_with(&self, query: &GetSyncConflictsQuery) -> Result<Vec<models::SyncConflicts>> {
let path = "/sync/conflicts".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List sync conflicts
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetSyncConflictsQuery) -> Items<models::SyncConflicts> {
let path = "/sync/conflicts".to_owned();
self.client.items(&path, query.to_query())
}
/// Replace a sync conflict
///
/// `PUT /sync/conflicts/{id}`
///
/// Replaces job, relationship, type and all conflict data. This does not modify either synchronized record. Requires "churchcore: administer persons" permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncConflictUpdate {
/// data: vec![models::SyncConflictDataCreate {
/// key: "abc123".into(),
/// value: "beispiel".into(),
/// ..Default::default()
/// }],
/// entity_mapping_id: 1,
/// job_id: "7e31c399-91b1-4148-bfdd-6c05b557a25c".into(),
/// r#type: "create".into(),
/// ..Default::default()
/// };
/// let result = client.sync().conflicts().update(1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::SyncConflictUpdate) -> Result<models::SyncConflicts> {
let path = format!("/sync/conflicts/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.sync().entity_mappings()`
#[derive(Clone, Copy)]
pub struct SyncEntityMappingsResource<'a> {
client: &'a Client,
}
impl<'a> SyncEntityMappingsResource<'a> {
/// Create an entity mapping
///
/// `POST /sync/entitymappings`
///
/// Registers a relationship without creating either underlying record. Provided ChurchTools or external IDs must not be linked for the same domain and source. Requires "churchcore: administer persons" permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncEntityMappingCreate {
/// domain_id: Some("42".into()),
/// domain_type: "status".into(),
/// source_entity_id: Some("p-42".into()),
/// source_id: 1,
/// status: "synced".into(),
/// ..Default::default()
/// };
/// let result = client.sync().entity_mappings().create(&body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::SyncEntityMappingCreate) -> Result<models::SyncEntityMapping> {
let path = "/sync/entitymappings".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete an entity mapping
///
/// `DELETE /sync/entitymappings/{id}`
///
/// Removes only the stored relationship; neither the ChurchTools record nor the external record is deleted. A missing mapping also returns `204`. Requires "churchcore: administer persons" permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().entity_mappings().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
let path = format!("/sync/entitymappings/{}", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get an entity mapping
///
/// `GET /sync/entitymappings/{id}`
///
/// Returns a stored relationship. Requires "churchcore: administer persons" permission.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-entitymappings-id");
/// let entity_mapping = client.sync().entity_mappings().get(1)?;
/// println!("{}", entity_mapping.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, id: impl Display) -> Result<models::SyncEntityMapping> {
let path = format!("/sync/entitymappings/{}", seg(id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List entity mappings
///
/// `GET /sync/entitymappings`
///
/// Lists relationships between ChurchTools records and external records, newest mapping ID first. `domainId` and `sourceEntityId` are record identifiers; `sourceId` identifies the external connection. Requires "churchcore: administer persons" permission.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-entitymappings");
/// for entity_mapping in client.sync().entity_mappings().list()? {
/// println!("{}", entity_mapping.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::SyncEntityMapping>> {
self.list_with(&Default::default())
}
/// List entity mappings
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /sync/entitymappings`
///
/// Lists relationships between ChurchTools records and external records, newest mapping ID first. `domainId` and `sourceEntityId` are record identifiers; `sourceId` identifies the external connection. Requires "churchcore: administer persons" permission.
pub fn list_with(&self, query: &GetSyncEntitymappingsQuery) -> Result<Vec<models::SyncEntityMapping>> {
let path = "/sync/entitymappings".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List entity mappings
///
/// Like [`Self::list_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_iter(&self, query: &GetSyncEntitymappingsQuery) -> Items<models::SyncEntityMapping> {
let path = "/sync/entitymappings".to_owned();
self.client.items(&path, query.to_query())
}
/// Update or create an entity mapping
///
/// `PUT /sync/entitymappings/{id}`
///
/// Updates the relationship. Requires "churchcore: administer persons" permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncEntityMappingUpdate {
/// domain_id: Some("42".into()),
/// domain_type: "status".into(),
/// source_entity_id: Some("p-42".into()),
/// source_id: 1,
/// status: "synced".into(),
/// ..Default::default()
/// };
/// let result = client.sync().entity_mappings().update(1, &body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, id: impl Display, body: &models::SyncEntityMappingUpdate) -> Result<models::SyncEntityMapping> {
let path = format!("/sync/entitymappings/{}", seg(id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.sync().externalsystems()`
#[derive(Clone, Copy)]
pub struct SyncExternalsystemsResource<'a> {
client: &'a Client,
}
impl<'a> SyncExternalsystemsResource<'a> {
pub fn adapter_proxy(&self) -> SyncExternalsystemsAdapterProxyResource<'a> {
SyncExternalsystemsAdapterProxyResource { client: self.client }
}
pub fn field_mappings(&self) -> SyncExternalsystemsFieldMappingsResource<'a> {
SyncExternalsystemsFieldMappingsResource { client: self.client }
}
pub fn job_configs(&self) -> SyncExternalsystemsJobConfigsResource<'a> {
SyncExternalsystemsJobConfigsResource { client: self.client }
}
/// Create an external connection
///
/// `POST /sync/externalsystems`
///
/// Creates a connection using an existing adapter name and copies available field-mapping presets. Outside the trial period, the licensed connection limit is checked.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ExternalSystemCreate {
/// access_header_values: serde_json::json!({}),
/// adapter: "churchtools".into(),
/// name: "Accounting system".into(),
/// ..Default::default()
/// };
/// let result = client.sync().externalsystems().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::ExternalSystemCreate) -> Result<models::ExternalSystem> {
let path = "/sync/externalsystems".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete an external connection
///
/// `DELETE /sync/externalsystems/{externalSystemId}`
///
/// Deletes the connection, its job configurations, related job logs and executions, field mappings and entity mappings. Synchronized records themselves are not deleted. Returns `204` if the connection is missing.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, external_system_id: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}", seg(external_system_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Delete all mappings for an external connection
///
/// `DELETE /sync/externalsystems/{externalSystemId}/entitymappings`
///
/// Removes all relationships belonging to the external connection. Underlying records remain. Returns `204` when no mapping exists. Requires "churchcore: administer persons" permission.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().delete_entity_mappings(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_entity_mappings(&self, external_system_id: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/entitymappings", seg(external_system_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get an external connection
///
/// `GET /sync/externalsystems/{externalSystemId}`
///
/// Returns connection settings with masked access credentials.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-externalsystems-externalSystemId");
/// let externalsystem = client.sync().externalsystems().get(1)?;
/// println!("{}", externalsystem.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, external_system_id: impl Display) -> Result<models::ExternalSystem> {
let path = format!("/sync/externalsystems/{}", seg(external_system_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List external connections
///
/// `GET /sync/externalsystems`
///
/// Lists configured connections, including their adapter names and job counts. A connection identifies one external installation or account; several can use the same adapter.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-externalsystems");
/// for externalsystem in client.sync().externalsystems().list()? {
/// println!("{}", externalsystem.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::ExternalSystem>> {
let path = "/sync/externalsystems".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Test a saved external connection
///
/// `POST /sync/externalsystems/{externalSystemId}/test`
///
/// Calls the adapter’s connection test using the saved settings. This is a connection check, not a synchronization run.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().test(1)?;
/// # Ok(())
/// # }
/// ```
pub fn test(&self, external_system_id: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/test", seg(external_system_id));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Test proposed external connection settings
///
/// `POST /sync/externalsystems/test`
///
/// Runs the adapter's connection test without saving the supplied settings.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncExternalSystemTestCreate {
/// access_header_values: serde_json::json!({}),
/// adapter: "churchtools".into(),
/// name: "Accounting system".into(),
/// ..Default::default()
/// };
/// let result = client.sync().externalsystems().test_settings(&body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn test_settings(&self, body: &models::SyncExternalSystemTestCreate) -> Result<serde_json::Value> {
let path = "/sync/externalsystems/test".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Update an external connection
///
/// `PUT /sync/externalsystems/{externalSystemId}`
///
/// Changes the name and adapter and merges supplied access headers.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::ExternalSystemUpdate {
/// access_header_values: serde_json::json!({}),
/// adapter: "churchtools".into(),
/// name: "Accounting system".into(),
/// id: 1,
/// ..Default::default()
/// };
/// let result = client.sync().externalsystems().update(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, external_system_id: impl Display, body: &models::ExternalSystemUpdate) -> Result<models::ExternalSystem> {
let path = format!("/sync/externalsystems/{}", seg(external_system_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.sync().externalsystems().adapter_proxy()`
#[derive(Clone, Copy)]
pub struct SyncExternalsystemsAdapterProxyResource<'a> {
client: &'a Client,
}
impl<'a> SyncExternalsystemsAdapterProxyResource<'a> {
/// Proxy POST to a sync adapter
///
/// `POST /sync/externalsystems/{externalSystemId}/adapterproxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. `externalSystemId` set to `0` selects the local ChurchTools system.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().adapter_proxy().create(1, "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn create(&self, external_system_id: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/adapterproxy/{}", seg(external_system_id), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Post, &path, &query, None).map(|_| ())
}
/// Proxy DELETE to a sync adapter
///
/// `DELETE /sync/externalsystems/{externalSystemId}/adapterproxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. `externalSystemId` set to `0` selects the local ChurchTools system.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().adapter_proxy().delete(1, "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, external_system_id: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/adapterproxy/{}", seg(external_system_id), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Proxy GET to a sync adapter
///
/// `GET /sync/externalsystems/{externalSystemId}/adapterproxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. `externalSystemId` set to `0` selects the local ChurchTools system.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().adapter_proxy().get(1, "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn get(&self, external_system_id: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/adapterproxy/{}", seg(external_system_id), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
/// Proxy PATCH to a sync adapter
///
/// `PATCH /sync/externalsystems/{externalSystemId}/adapterproxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. `externalSystemId` set to `0` selects the local ChurchTools system.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().adapter_proxy().patch(1, "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, external_system_id: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/adapterproxy/{}", seg(external_system_id), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Patch, &path, &query, None).map(|_| ())
}
/// Proxy PUT to a sync adapter
///
/// `PUT /sync/externalsystems/{externalSystemId}/adapterproxy/{uri}`
///
/// Forwards the HTTP method and query parameters to the adapter’s `/api/{uri}` route. Response status, body and `Content-Type` come from the adapter without a `data` wrapper. `externalSystemId` set to `0` selects the local ChurchTools system.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().adapter_proxy().update(1, "adapter/info")?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, external_system_id: impl Display, uri: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/adapterproxy/{}", seg(external_system_id), seg(uri));
let query: Query = Query::new();
self.client.request(Method::Put, &path, &query, None).map(|_| ())
}
}
/// `client.sync().externalsystems().field_mappings()`
#[derive(Clone, Copy)]
pub struct SyncExternalsystemsFieldMappingsResource<'a> {
client: &'a Client,
}
impl<'a> SyncExternalsystemsFieldMappingsResource<'a> {
/// Delete field mappings for a domain
///
/// `DELETE /sync/externalsystems/{externalSystemId}/fieldmappings/{domainType}`
///
/// Removes the stored field mapping and its entries for this connection and domain. A missing mapping also returns `204`.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().field_mappings().delete(1, "status")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, external_system_id: impl Display, domain_type: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/fieldmappings/{}", seg(external_system_id), seg(domain_type));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get field mappings for a domain
///
/// `GET /sync/externalsystems/{externalSystemId}/fieldmappings/{domainType}`
///
/// Returns mappings in both directions. If the connection exists but no mapping is stored for the domain, returns an unsaved mapping.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-externalsystems-id-fieldmappings-domaintype");
/// let field_mapping = client.sync().externalsystems().field_mappings().get(1, "status")?;
/// println!("{:?}", field_mapping.id);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, external_system_id: impl Display, domain_type: impl Display) -> Result<models::FieldMapping> {
let path = format!("/sync/externalsystems/{}/fieldmappings/{}", seg(external_system_id), seg(domain_type));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List fields without mapping suggestions
///
/// `GET /sync/externalsystems/{externalSystemId}/fieldmappings/{domainType}/nosuggestions`
///
/// Returns source fields whose adapter preset has no target suggestion, grouped by system. This reports preset coverage, not all unselected job fields.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-externalsystems-id-fieldmappings-domaintype-nosuggestions");
/// let result = client.sync().externalsystems().field_mappings().get_nosuggestions(1, "status")?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn get_nosuggestions(&self, external_system_id: impl Display, domain_type: impl Display) -> Result<serde_json::Value> {
let path = format!("/sync/externalsystems/{}/fieldmappings/{}/nosuggestions", seg(external_system_id), seg(domain_type));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List field mappings for a connection
///
/// `GET /sync/externalsystems/{externalSystemId}/fieldmappings`
///
/// Lists stored domain-level field mappings. These define available translations between fields; a job separately selects which mappings to use.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-externalsystems-externalSystemId-fieldmappings");
/// for field_mapping in client.sync().externalsystems().field_mappings().list(1)? {
/// println!("{:?}", field_mapping.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, external_system_id: impl Display) -> Result<Vec<models::FieldMapping>> {
let path = format!("/sync/externalsystems/{}/fieldmappings", seg(external_system_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Replace field mappings for a domain
///
/// `PUT /sync/externalsystems/{externalSystemId}/fieldmappings/{domainType}`
///
/// Replaces both direction lists. Direction is inferred from the enclosing list.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncFieldMappingUpdate {
/// property_mappings_es_to_master: vec![models::SyncFieldMappingEntryCreate {
/// from: "firstName".into(),
/// from_filter: "".into(),
/// others: serde_json::json!({}),
/// to: "firstName".into(),
/// to_filter: "".into(),
/// value_mapping: serde_json::json!({}),
/// ..Default::default()
/// }],
/// property_mappings_master_to_es: vec![models::SyncFieldMappingEntryCreate {
/// from: "firstName".into(),
/// from_filter: "".into(),
/// others: serde_json::json!({}),
/// to: "firstName".into(),
/// to_filter: "".into(),
/// value_mapping: serde_json::json!({}),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.sync().externalsystems().field_mappings().update(1, "status", &body)?;
/// println!("{:?}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, external_system_id: impl Display, domain_type: impl Display, body: &models::SyncFieldMappingUpdate) -> Result<models::FieldMapping> {
let path = format!("/sync/externalsystems/{}/fieldmappings/{}", seg(external_system_id), seg(domain_type));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.sync().externalsystems().job_configs()`
#[derive(Clone, Copy)]
pub struct SyncExternalsystemsJobConfigsResource<'a> {
client: &'a Client,
}
impl<'a> SyncExternalsystemsJobConfigsResource<'a> {
pub fn executions(&self) -> SyncExternalsystemsJobConfigsExecutionsResource<'a> {
SyncExternalsystemsJobConfigsExecutionsResource { client: self.client }
}
/// Create a sync job configuration
///
/// `POST /sync/externalsystems/{externalSystemId}/jobconfigs`
///
/// Selected fields and record filters are managed through the properties and filter endpoints.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncJobConfigurationCreate {
/// auto_schedule_enabled: false,
/// domain_type: "person".into(),
/// name: "Synchronize people".into(),
/// ..Default::default()
/// };
/// let result = client.sync().externalsystems().job_configs().create(1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, external_system_id: impl Display, body: &models::SyncJobConfigurationCreate) -> Result<models::JobConfigurationReturn> {
let path = format!("/sync/externalsystems/{}/jobconfigs", seg(external_system_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a sync job configuration
///
/// `DELETE /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}`
///
/// Deletes the configuration together with selected properties, filters, logs and associated background executions. Missing jobs also return `204`.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().job_configs().delete(1, 1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, external_system_id: impl Display, job_id: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Clear sync job record filters
///
/// `DELETE /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}/filter`
///
/// Deletes all record filters; the job configuration remains.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().job_configs().delete_filter(1, 1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_filter(&self, external_system_id: impl Display, job_id: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}/filter", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Clear sync job selected fields
///
/// `DELETE /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}/properties`
///
/// Deletes all selected fields; the job configuration remains.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.sync().externalsystems().job_configs().delete_properties(1, 1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete_properties(&self, external_system_id: impl Display, job_id: impl Display) -> Result<()> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}/properties", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Find a sync job configuration
///
/// `GET /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}`
///
/// Returns configurations matching the job and external connection IDs.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-externalsystems-externalSystemId-jobconfigs-jobId");
/// for job_config in client.sync().externalsystems().job_configs().get(1, 1)? {
/// println!("{}", job_config.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn get(&self, external_system_id: impl Display, job_id: impl Display) -> Result<Vec<models::JobConfigurationReturn>> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get sync job record filters
///
/// `GET /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}/filter`
///
/// Returns record filters grouped by direction.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-externalsystems-externalSystemId-jobconfigs-jobId-filter");
/// let filter = client.sync().externalsystems().job_configs().get_filter(1, 1)?;
/// println!("{:?}", filter);
/// # Ok(())
/// # }
/// ```
pub fn get_filter(&self, external_system_id: impl Display, job_id: impl Display) -> Result<models::SyncJobFilters> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}/filter", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get sync job selected fields
///
/// `GET /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}/properties`
///
/// Returns selected fields grouped by direction.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-externalsystems-externalSystemId-jobconfigs-jobId-properties");
/// let property = client.sync().externalsystems().job_configs().get_properties(1, 1)?;
/// println!("{}", property.domain_type);
/// # Ok(())
/// # }
/// ```
pub fn get_properties(&self, external_system_id: impl Display, job_id: impl Display) -> Result<models::SyncJobProperties> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}/properties", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List jobs for an external connection
///
/// `GET /sync/externalsystems/{externalSystemId}/jobconfigs`
///
/// Lists job configurations belonging to the external connection.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-sync-externalsystems-id-jobconfigs");
/// for job_config in client.sync().externalsystems().job_configs().list(1)? {
/// println!("{}", job_config.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, external_system_id: impl Display) -> Result<Vec<models::JobConfigurationReturn>> {
let path = format!("/sync/externalsystems/{}/jobconfigs", seg(external_system_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Schedule a sync execution
///
/// `POST /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}/start`
///
/// Schedules the configuration as a background job. A `204` response confirms scheduling, not successful synchronization. Inspect `/sync/executions` and `/sync/logs` for progress. Requires an enabled license or active trial.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncExecutionCreate {
/// is_dry_run: Some(true),
/// ..Default::default()
/// };
/// client.sync().externalsystems().job_configs().start(1, 1, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn start(&self, external_system_id: impl Display, job_id: impl Display, body: &models::SyncExecutionCreate) -> Result<()> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}/start", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Post, &path, &query, Some(&body)).map(|_| ())
}
/// Update a sync job configuration
///
/// `PUT /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}`
///
/// Updates the job configuration for the external connection.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncJobConfigurationUpdate {
/// auto_schedule_enabled: false,
/// domain_type: "person".into(),
/// name: "Synchronize people".into(),
/// id: 1,
/// ..Default::default()
/// };
/// let result = client.sync().externalsystems().job_configs().update(1, 1, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, external_system_id: impl Display, job_id: impl Display, body: &models::SyncJobConfigurationUpdate) -> Result<models::JobConfigurationReturn> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
/// Replace sync job record filters
///
/// `PUT /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}/filter`
///
/// Filter operators and values are interpreted by the adapter.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncJobFiltersUpdate {
/// es: vec![models::SyncJobFilterCreate {
/// field: "statusId".into(),
/// system: "master".into(),
/// values: serde_json::json!({}),
/// ..Default::default()
/// }],
/// master: vec![models::SyncJobFilterCreate {
/// field: "statusId".into(),
/// system: "master".into(),
/// values: serde_json::json!({}),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.sync().externalsystems().job_configs().update_filter(1, 1, &body)?;
/// println!("{:?}", result);
/// # Ok(())
/// # }
/// ```
pub fn update_filter(&self, external_system_id: impl Display, job_id: impl Display, body: &models::SyncJobFiltersUpdate) -> Result<models::SyncJobFilters> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}/filter", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
/// Replace sync job selected fields
///
/// `PUT /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}/properties`
///
/// Value mappings and adapter options are inherited from the referenced mapping.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::SyncJobPropertiesUpdate {
/// property_mappings_es_to_master: vec![models::SyncJobPropertyCreate {
/// field_mapping_id: 1,
/// from: "firstName".into(),
/// from_filter: "".into(),
/// system: "master".into(),
/// to: "firstName".into(),
/// to_filter: "".into(),
/// ..Default::default()
/// }],
/// property_mappings_master_to_es: vec![models::SyncJobPropertyCreate {
/// field_mapping_id: 1,
/// from: "firstName".into(),
/// from_filter: "".into(),
/// system: "master".into(),
/// to: "firstName".into(),
/// to_filter: "".into(),
/// ..Default::default()
/// }],
/// ..Default::default()
/// };
/// let result = client.sync().externalsystems().job_configs().update_properties(1, 1, &body)?;
/// println!("{}", result.domain_type);
/// # Ok(())
/// # }
/// ```
pub fn update_properties(&self, external_system_id: impl Display, job_id: impl Display, body: &models::SyncJobPropertiesUpdate) -> Result<models::SyncJobProperties> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}/properties", seg(external_system_id), seg(job_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.sync().externalsystems().job_configs().executions()`
#[derive(Clone, Copy)]
pub struct SyncExternalsystemsJobConfigsExecutionsResource<'a> {
client: &'a Client,
}
impl<'a> SyncExternalsystemsJobConfigsExecutionsResource<'a> {
/// Get a sync execution configuration snapshot
///
/// `GET /sync/externalsystems/{externalSystemId}/jobconfigs/{jobId}/executions/{executionId}`
///
/// Returns the arguments saved for a background execution. Adapter credentials and the external connection headers are removed. Mapping system values are normalized to `master` and `es`.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let execution = client.sync().externalsystems().job_configs().executions().get(1, 1, "run-123")?;
/// println!("{}", execution.domain_type);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, external_system_id: impl Display, job_id: impl Display, execution_id: impl Display) -> Result<models::SyncExecutionDetails> {
let path = format!("/sync/externalsystems/{}/jobconfigs/{}/executions/{}", seg(external_system_id), seg(job_id), seg(execution_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.tags()`
#[derive(Clone, Copy)]
pub struct TagsResource<'a> {
client: &'a Client,
}
impl<'a> TagsResource<'a> {
/// Attach an existing tag to an object
///
/// `PUT /tags/{domainType}/{domainId}/{tagId}`
///
/// Attaches the tag to the target without a request body. Requires domain-specific assignment rights for the target. An existing assignment is reused. A new assignment requires the tag to exist in the specified domain. The response contains the tag with `count` normally set to `1`, not the tag link.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-tags-domainType-domainId-tagId");
/// let tag = client.tags().attach("person", 35, 42)?;
/// println!("{}", tag.name);
/// # Ok(())
/// # }
/// ```
pub fn attach(&self, domain_type: impl Display, domain_id: impl Display, tag_id: impl Display) -> Result<models::TagWithCount> {
let path = format!("/tags/{}/{}/{}", seg(domain_type), seg(domain_id), seg(tag_id));
let query: Query = Query::new();
self.client.request_data(Method::Put, &path, &query, None)
}
/// Find or create a tag and attach it to an object
///
/// `POST /tags/{domainType}/{domainId}`
///
/// Finds or creates the named tag and attaches it to the target. Requires domain-specific assignment rights: person-tag visibility and person write or group-internal edit rights, group visibility and applicable group-edit rights, song-category edit rights, or appointment edit rights. Separate tag administration rights are not required. An existing assignment is reused. The response contains the tag with `count` normally set to `1`, not the tag link.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-tags-domainType-domainId");
/// let body = models::TagAssignmentCreate {
/// name: "Mission".into(),
/// ..Default::default()
/// };
/// let tag = client.tags().attach_new("person", 35, &body)?;
/// println!("{}", tag.name);
/// # Ok(())
/// # }
/// ```
pub fn attach_new(&self, domain_type: impl Display, domain_id: impl Display, body: &models::TagAssignmentCreate) -> Result<models::TagWithCount> {
let path = format!("/tags/{}/{}", seg(domain_type), seg(domain_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Create new tag
///
/// `POST /tags/{domainType}`
///
/// Creates an unused tag with `count` set to `0`. Requires "edit masterdata" permission in `churchdb`, `churchgroup`, or `churchservice`, or "admin appointment tags" permission in `churchcal`, depending on the domain. The scheduled purge may remove unused song tags and, when person settings are disabled, unused person tags not referenced by services. It retains group and appointment tags.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-tags-domainType");
/// let body = models::TagCreate {
/// name: "Mission".into(),
/// ..Default::default()
/// };
/// let result = client.tags().create("person", &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, domain_type: impl Display, body: &models::TagCreate) -> Result<models::TagWithCount> {
let path = format!("/tags/{}", seg(domain_type));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete tag
///
/// `DELETE /tags/{tagId}`
///
/// Deletes the tag and all its object assignments through the database cascade. Requires "edit masterdata" permission in `churchdb`, `churchgroup`, or `churchservice`, or "admin appointment tags" permission in `churchcal`, depending on the domain. No dry-run or delete-conflict workflow is available.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.tags().delete(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, tag_id: impl Display) -> Result<()> {
let path = format!("/tags/{}", seg(tag_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Remove tag from domain object
///
/// `DELETE /tags/{domainType}/{domainId}/{tagId}`
///
/// Removes the matching assignment while retaining the tag itself. Requires the same domain-specific assignment rights as adding a tag. A missing assignment succeeds, including when the tag is missing or belongs to another domain. A missing target may still produce `404`, depending on its domain policy.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.tags().detach("person", 35, 42)?;
/// # Ok(())
/// # }
/// ```
pub fn detach(&self, domain_type: impl Display, domain_id: impl Display, tag_id: impl Display) -> Result<()> {
let path = format!("/tags/{}/{}/{}", seg(domain_type), seg(domain_id), seg(tag_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get tag
///
/// `GET /tags/{tagId}`
///
/// Returns one tag. Requires "edit masterdata" permission in `churchdb`, `churchgroup`, or `churchservice`, or "admin appointment tags" permission in `churchcal`, depending on the domain. Unlike object-specific reads, this endpoint requires administration rights. The tag’s `count` is normally `1`, not a calculated usage count.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-tags-tagId");
/// let tag = client.tags().get(42)?;
/// println!("{}", tag.name);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, tag_id: impl Display) -> Result<models::TagWithCount> {
let path = format!("/tags/{}", seg(tag_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get tags for domain type
///
/// `GET /tags/{domainType}`
///
/// Lists all tags in the domain, including currently unused tags, sorted by name and without per-object visibility checks. Each tag’s `count` includes links to objects the caller may not be able to view, while `meta.count` is the number of returned tags.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-tags-domainType");
/// for tag in client.tags().list("person")? {
/// println!("{}", tag.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, domain_type: impl Display) -> Result<Vec<models::TagWithCount>> {
let path = format!("/tags/{}", seg(domain_type));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get tags for domain object
///
/// `GET /tags/{domainType}/{domainId}`
///
/// Lists tags attached to this domain object, sorted by name and without pagination. Requires the domain’s tag-view permission for the target. Each tag’s `count` is normally `1`, not its overall usage count, while `meta.count` is the number of returned tags.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-tags-domainType-domainId");
/// for for_object in client.tags().list_for_object("person", 35)? {
/// println!("{}", for_object.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_for_object(&self, domain_type: impl Display, domain_id: impl Display) -> Result<Vec<models::TagWithCount>> {
let path = format!("/tags/{}/{}", seg(domain_type), seg(domain_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Replace tag properties
///
/// `PUT /tags/{tagId}`
///
/// Replaces name, description and color while keeping the domain unchanged. Requires "edit masterdata" permission in `churchdb`, `churchgroup`, or `churchservice`, or "admin appointment tags" permission in `churchcal`, depending on the domain. The uniqueness check reads `id` instead of the route’s `tagId`, so retaining the same name may be rejected as a duplicate.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-tags-tagId");
/// let body = models::TagUpdate {
/// name: "Mission".into(),
/// ..Default::default()
/// };
/// let result = client.tags().update(42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, tag_id: impl Display, body: &models::TagUpdate) -> Result<models::TagWithCount> {
let path = format!("/tags/{}", seg(tag_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.translations()`
#[derive(Clone, Copy)]
pub struct TranslationsResource<'a> {
client: &'a Client,
}
impl<'a> TranslationsResource<'a> {
pub fn languages(&self) -> TranslationsLanguagesResource<'a> {
TranslationsLanguagesResource { client: self.client }
}
/// Delete translation key
///
/// `DELETE /translations/{keyId}`
///
/// Marks a locally created translation key as deleted and clears generated message files. It no longer appears in translation queries. Product-supplied keys are rejected with 400. This is a soft deletion; language entries are not individually deleted by this operation. There is no dry-run mode.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.translations().delete(1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, key_id: impl Display) -> Result<()> {
let path = format!("/translations/{}", seg(key_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get all translations
///
/// `GET /translations`
///
/// Returns non-deleted translation keys with matching non-deleted language entries. updated_by_church and needs_check filter language entries; omit either to include both boolean states. The returned translations map contains the matching entries, and keys without any match are omitted. The list is unpaginated, has no guaranteed order and returns meta.count, not page metadata.
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-translations");
/// for translation in client.translations().list()? {
/// println!("{}", translation.id);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::TranslationKey>> {
self.list_with(&Default::default())
}
/// Get all translations
///
/// Like [`Self::list`], with query parameters.
///
/// `GET /translations`
///
/// Returns non-deleted translation keys with matching non-deleted language entries. updated_by_church and needs_check filter language entries; omit either to include both boolean states. The returned translations map contains the matching entries, and keys without any match are omitted. The list is unpaginated, has no guaranteed order and returns meta.count, not page metadata.
pub fn list_with(&self, query: &GetTranslationsQuery) -> Result<Vec<models::TranslationKey>> {
let path = "/translations".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Get all translation keys, which match a translation
///
/// `GET /translations/keysbytext`
///
/// Finds keys whose non-deleted translation text exactly matches the trimmed query in any language. This is not a substring search. Keys are returned in a nested array: data always contains one array, which is empty when nothing matches; meta.count is therefore always 1. A key can appear more than once if multiple languages match. No global ordering or pagination is applied.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-translations-keysbytext");
/// let query = GetTranslationsKeysbytextQuery {
/// query: Some("Welcome".into()),
/// ..Default::default()
/// };
/// for keys_by_text in client.translations().list_keys_by_text(&query)? {
/// println!("{:?}", keys_by_text);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_keys_by_text(&self, query: &GetTranslationsKeysbytextQuery) -> Result<Vec<Vec<String>>> {
let path = "/translations/keysbytext".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a local translation key
///
/// `PUT /translations/{keyId}`
///
/// Changes the key string and module of an installation-created translation key. Both fields are required; individual translated texts are unchanged. Product-supplied keys are rejected with 400. The response is empty.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::TranslationKeyUpdate {
/// key: "mychurch.welcome".into(),
/// module: "churchcore".into(),
/// ..Default::default()
/// };
/// client.translations().update(1, &body)?;
/// # Ok(())
/// # }
/// ```
pub fn update(&self, key_id: impl Display, body: &models::TranslationKeyUpdate) -> Result<()> {
let path = format!("/translations/{}", seg(key_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request(Method::Put, &path, &query, Some(&body)).map(|_| ())
}
}
/// `client.translations().languages()`
#[derive(Clone, Copy)]
pub struct TranslationsLanguagesResource<'a> {
client: &'a Client,
}
impl<'a> TranslationsLanguagesResource<'a> {
/// Delete translation language for key
///
/// `DELETE /translations/{keyId}/languages/{languageId}`
///
/// Marks one language translation as deleted, updates its modification timestamp and clears generated message files. The key and other language entries remain. An unknown key/language pair returns 404. Repeating the operation on an existing already-deleted entry also succeeds with 204. There is no dry-run mode.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.translations().languages().delete(1, 1)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, key_id: impl Display, language_id: impl Display) -> Result<()> {
let path = format!("/translations/{}/languages/{}", seg(key_id), seg(language_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
}
/// `client.two_factor()`
#[derive(Clone, Copy)]
pub struct TwoFactorResource<'a> {
client: &'a Client,
}
impl<'a> TwoFactorResource<'a> {
/// Verify an authenticator code during enrollment
///
/// `POST /twofactor/totp`
///
/// Checks a code against the stored authenticator secret for the current person. Only the current person may verify their own secret. Initialization must have completed first. A successful call returns status=success and records the code as used; it does not enable two-factor authentication. Call PUT /persons/{personId}/settings/twofactor separately to activate. Missing secrets, invalid codes and codes already recorded as used produce 400. Keep the code as a string to preserve leading zeroes.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::PersonTwoFactorVerify {
/// code: "012345".into(),
/// person_id: 42,
/// ..Default::default()
/// };
/// let two_factor = client.two_factor().totp(&body)?;
/// println!("{}", two_factor.status);
/// # Ok(())
/// # }
/// ```
pub fn totp(&self, body: &models::PersonTwoFactorVerify) -> Result<models::PostTwofactorTotpData> {
let path = "/twofactor/totp".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
}
/// `client.website()`
#[derive(Clone, Copy)]
pub struct WebsiteResource<'a> {
client: &'a Client,
}
impl<'a> WebsiteResource<'a> {
pub fn data(&self) -> WebsiteDataResource<'a> {
WebsiteDataResource { client: self.client }
}
/// `GET /website/starttest`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-website-starttest");
/// client.website().get_start_test()?;
/// # Ok(())
/// # }
/// ```
pub fn get_start_test(&self) -> Result<()> {
let path = "/website/starttest".to_owned();
let query: Query = Query::new();
self.client.request(Method::Get, &path, &query, None).map(|_| ())
}
}
/// `client.website().data()`
#[derive(Clone, Copy)]
pub struct WebsiteDataResource<'a> {
client: &'a Client,
}
impl<'a> WebsiteDataResource<'a> {
/// `POST /website/data`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// let body = models::WebsiteDataCreate {
/// domain_id: 42,
/// domain_type: "calendar".into(),
/// ..Default::default()
/// };
/// let result = client.website().data().create(&body)?;
/// println!("{}", result.id);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::WebsiteDataCreate) -> Result<models::WebsiteDataWithoutInclude> {
let path = "/website/data".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// `DELETE /website/data/{id}`
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.website().data().delete(4)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, id: impl Display) -> Result<()> {
let path = format!("/website/data/{}", seg(id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// `GET /website/data`
///
/// Get the data that is shared with the CT website
///
/// Use [`Self::list_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-website-data");
/// for item in client.website().data().list()? {
/// println!("{:?}", item);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<serde_json::Value>> {
self.list_with(&Default::default())
}
/// `GET /website/data`
///
/// Like [`Self::list`], with query parameters.
///
/// Get the data that is shared with the CT website
pub fn list_with(&self, query: &GetWebsiteDataQuery) -> Result<Vec<serde_json::Value>> {
let path = "/website/data".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.whoami()`
#[derive(Clone, Copy)]
pub struct WhoamiResource<'a> {
client: &'a Client,
}
impl<'a> WhoamiResource<'a> {
/// Currently logged in user.
///
/// `GET /whoami`
///
/// This endpoint returns the current user. If the request is unauthorized, the anonymous user (aka public user) is returned.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-whoami");
/// let whoami = client.whoami().get()?;
/// println!("{:?}", whoami.title);
/// # Ok(())
/// # }
/// ```
pub fn get(&self) -> Result<models::Person> {
self.get_with(&Default::default())
}
/// Currently logged in user.
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /whoami`
///
/// This endpoint returns the current user. If the request is unauthorized, the anonymous user (aka public user) is returned.
pub fn get_with(&self, query: &GetWhoamiQuery) -> Result<models::Person> {
let path = "/whoami".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.widgets()`
#[derive(Clone, Copy)]
pub struct WidgetsResource<'a> {
client: &'a Client,
}
impl<'a> WidgetsResource<'a> {
/// `GET /widgets/blog`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-widgets-blog");
/// let blog = client.widgets().get_blog()?;
/// println!("{:?}", blog.title);
/// # Ok(())
/// # }
/// ```
pub fn get_blog(&self) -> Result<models::GetWidgetsBlogData> {
let path = "/widgets/blog".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// `GET /widgets/rss`
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-widgets-rss");
/// let rss = client.widgets().get_rss()?;
/// println!("{}", rss.title);
/// # Ok(())
/// # }
/// ```
pub fn get_rss(&self) -> Result<models::RssFeed> {
let path = "/widgets/rss".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.wiki()`
#[derive(Clone, Copy)]
pub struct WikiResource<'a> {
client: &'a Client,
}
impl<'a> WikiResource<'a> {
pub fn categories(&self) -> WikiCategoriesResource<'a> {
WikiCategoriesResource { client: self.client }
}
/// List wiki pages
///
/// `GET /wiki/pages`
///
/// Lists the latest revisions of non-system, non-redirect pages in viewable categories. Guest category permissions are supported. Omitted/empty wiki_category_ids selects every viewable category; inaccessible IDs are silently dropped. Without query, ordering defaults to display title, then GUID. With query, default ranking prefers matching category main pages, then title matches, exact-content matches and finally matches containing all query words. Explicit order_fields overrides ranking. Pagination is applied after finding and enriching all matching pages. Text is omitted unless include\[\]=text; include\[\]=preview returns an unrendered stored-text prefix, which may contain raw HTML. searchPreview is independently included when query is supplied. meta contains page count and pagination total/limit/current/lastPage; lastPage is 0 for no results.
///
/// Use [`Self::list_pages_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-wiki-pages");
/// for page in client.wiki().list_pages()? {
/// println!("{}", page.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_pages(&self) -> Result<Vec<models::SimpleWikiPage>> {
self.list_pages_with(&Default::default())
}
/// List wiki pages
///
/// Like [`Self::list_pages`], with query parameters.
///
/// `GET /wiki/pages`
///
/// Lists the latest revisions of non-system, non-redirect pages in viewable categories. Guest category permissions are supported. Omitted/empty wiki_category_ids selects every viewable category; inaccessible IDs are silently dropped. Without query, ordering defaults to display title, then GUID. With query, default ranking prefers matching category main pages, then title matches, exact-content matches and finally matches containing all query words. Explicit order_fields overrides ranking. Pagination is applied after finding and enriching all matching pages. Text is omitted unless include\[\]=text; include\[\]=preview returns an unrendered stored-text prefix, which may contain raw HTML. searchPreview is independently included when query is supplied. meta contains page count and pagination total/limit/current/lastPage; lastPage is 0 for no results.
pub fn list_pages_with(&self, query: &GetWikiPagesQuery) -> Result<Vec<models::SimpleWikiPage>> {
let path = "/wiki/pages".to_owned();
let query: Query = query.to_query();
self.client.collect_pages(&path, query)
}
/// List wiki pages
///
/// Like [`Self::list_pages_with`], but lazy: each page is fetched only when the iteration reaches it.
/// Breaking off early saves the remaining requests.
pub fn list_pages_iter(&self, query: &GetWikiPagesQuery) -> Items<models::SimpleWikiPage> {
let path = "/wiki/pages".to_owned();
self.client.items(&path, query.to_query())
}
/// Full-text search across wiki pages
///
/// `GET /wiki/search`
///
/// Searches latest non-system, non-redirect pages in categories the current user or guest can view. Omitted/empty wiki_category_ids means all viewable categories; inaccessible categories are silently dropped. Results are grouped by relevance: category-name main pages, title matches (shorter first), exact text matches and then matches containing all query words. Results are deduplicated by GUID and are not paginated. The query is not trimmed; SQL LIKE wildcard characters % and _ are interpreted. Results contain domain-object links and a text preview with Markdown emphasis for matches, not the full page. For paginated page resources, use GET /wiki/pages.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-wiki-search");
/// let query = GetWikiSearchQuery {
/// query: Some("welcome".into()),
/// ..Default::default()
/// };
/// for search in client.wiki().list_search(&query)? {
/// println!("{}", search.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list_search(&self, query: &GetWikiSearchQuery) -> Result<Vec<models::WikiSearchResult>> {
let path = "/wiki/search".to_owned();
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
}
/// `client.wiki().categories()`
#[derive(Clone, Copy)]
pub struct WikiCategoriesResource<'a> {
client: &'a Client,
}
impl<'a> WikiCategoriesResource<'a> {
pub fn pages(&self) -> WikiCategoriesPagesResource<'a> {
WikiCategoriesPagesResource { client: self.client }
}
/// Create a new wiki category
///
/// `POST /wiki/categories`
///
/// Creates a wiki category and an initial page titled main (version 1, empty text, Markdown enabled). Requires churchwiki edit masterdata. The creator receives view category and edit category permissions for the new category if missing. A nonexistent campusId silently resolves to null. The returned category has an empty permissions object; use the list to obtain page-operation hints.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-wiki-categories");
/// let body = models::WikiCategoryCreate {
/// file_access_without_permission: false,
/// in_menu: true,
/// name: "Dokumentation".into(),
/// sort_key: 10,
/// ..Default::default()
/// };
/// let result = client.wiki().categories().create(&body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, body: &models::WikiCategoryCreate) -> Result<models::WikiCategory> {
let path = "/wiki/categories".to_owned();
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a wiki category
///
/// `DELETE /wiki/categories/{wikiCategoryId}`
///
/// Deletes the category, all its wiki page versions and category view/edit permission assignments. Requires churchwiki edit masterdata. Existing pages do not block this deletion, and no page-level protected-system-page check is made by this handler. A missing category normally succeeds with 204. No request body or dry-run parameter is consumed.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.wiki().categories().delete(42)?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, wiki_category_id: impl Display) -> Result<()> {
let path = format!("/wiki/categories/{}", seg(wiki_category_id));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get all wiki categories
///
/// `GET /wiki/categories`
///
/// Lists wiki categories for which the current user (including a guest) has churchwiki view category permission. Categories organize pages and define their access permissions. Results are sorted by sortKey, then stored name, without pagination. inMenu does not filter this catalog. Each category’s canEdit/canDelete flags describe page operations based on edit category, not permission to rename or delete the category itself. The top-level permissions.editMasterData flag controls category administration. meta.count counts visible categories.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-wiki-categories");
/// for category in client.wiki().categories().list()? {
/// println!("{}", category.name);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self) -> Result<Vec<models::WikiCategory>> {
let path = "/wiki/categories".to_owned();
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a wiki category
///
/// `PUT /wiki/categories/{wikiCategoryId}`
///
/// Replaces the category’s name, sort order, menu flag, file-access flag and optional campus association. Requires churchwiki edit masterdata. name, sortKey, inMenu and fileAccessWithoutPermission are required; omitted/null or unknown campusId clears the association. Pages and their versions are retained. The response permissions object is normally empty.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("put-wiki-categories-id");
/// let body = models::WikiCategoryUpdate {
/// file_access_without_permission: false,
/// in_menu: true,
/// name: "Dokumentation".into(),
/// sort_key: 10,
/// ..Default::default()
/// };
/// let result = client.wiki().categories().update(42, &body)?;
/// println!("{}", result.name);
/// # Ok(())
/// # }
/// ```
pub fn update(&self, wiki_category_id: impl Display, body: &models::WikiCategoryUpdate) -> Result<models::WikiCategory> {
let path = format!("/wiki/categories/{}", seg(wiki_category_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Put, &path, &query, Some(&body))
}
}
/// `client.wiki().categories().pages()`
#[derive(Clone, Copy)]
pub struct WikiCategoriesPagesResource<'a> {
client: &'a Client,
}
impl<'a> WikiCategoriesPagesResource<'a> {
pub fn versions(&self) -> WikiCategoriesPagesVersionsResource<'a> {
WikiCategoriesPagesVersionsResource { client: self.client }
}
/// Create a wiki page
///
/// `POST /wiki/categories/{wikiCategoryId}/pages`
///
/// Creates a page with a generated stable GUID and version 1. Requires churchwiki edit category; creating a title that resolves to a protected system page additionally requires a super administrator. The trimmed title must be unique in the category across stored versions. Unicode ellipsis is normalized to three periods. Omitted text is stored as null but returned as an empty string. isMarkdown and onStartpage default to false; this differs from the main page automatically created with a new category, which starts with Markdown enabled.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("post-wiki-categories-id-pages");
/// let body = models::WikiPageCreate {
/// title: "My new wiki page".into(),
/// ..Default::default()
/// };
/// let result = client.wiki().categories().pages().create(42, &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn create(&self, wiki_category_id: impl Display, body: &models::WikiPageCreate) -> Result<models::WikiPage> {
let path = format!("/wiki/categories/{}/pages", seg(wiki_category_id));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Post, &path, &query, Some(&body))
}
/// Delete a wiki page
///
/// `DELETE /wiki/categories/{wikiCategoryId}/pages/{identifier}`
///
/// Deletes the page identified by GUID and every stored revision. Requires churchwiki edit category. Protected system pages in category 0 cannot be deleted through this endpoint, including by super administrators. Missing pages succeed with 204. Latest redirect pages targeting the deleted title have redirectTo cleared; older redirect revisions are retained. This deletion has no dry-run or version precondition.
///
/// # Example
///
/// ```no_run
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = Client::new("https://meinegemeinde.church.tools", None)?;
/// client.wiki().categories().pages().delete(42, "681F54E3-2EB7-40A4-84F0-EFF8E8F05727")?;
/// # Ok(())
/// # }
/// ```
pub fn delete(&self, wiki_category_id: impl Display, identifier: impl Display) -> Result<()> {
let path = format!("/wiki/categories/{}/pages/{}", seg(wiki_category_id), seg(identifier));
let query: Query = Query::new();
self.client.request(Method::Delete, &path, &query, None).map(|_| ())
}
/// Get a wiki page
///
/// `GET /wiki/categories/{wikiCategoryId}/pages/{identifier}`
///
/// Requires churchwiki view category permission, including any permissions assigned to guests. For a protected system page in category 0, super-administrator access also permits the individual read. Returns one page revision with text: Markdown is returned as stored, legacy HTML is sanitized, and null content becomes an empty string. Prefer the stable page GUID; legacy titles are accepted and Unicode ellipsis characters in titles are normalized to three periods. A version value of 0 behaves like omission and selects the latest revision; other nonzero values select that exact revision. Redirect pages are returned as data with redirectTo rather than followed.
///
/// Use [`Self::get_with`] to pass query parameters.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-wiki-categories-id-pages-identifier");
/// let page = client.wiki().categories().pages().get(42, "main")?;
/// println!("{}", page.title);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, wiki_category_id: impl Display, identifier: impl Display) -> Result<models::WikiPage> {
self.get_with(wiki_category_id, identifier, &Default::default())
}
/// Get a wiki page
///
/// Like [`Self::get`], with query parameters.
///
/// `GET /wiki/categories/{wikiCategoryId}/pages/{identifier}`
///
/// Requires churchwiki view category permission, including any permissions assigned to guests. For a protected system page in category 0, super-administrator access also permits the individual read. Returns one page revision with text: Markdown is returned as stored, legacy HTML is sanitized, and null content becomes an empty string. Prefer the stable page GUID; legacy titles are accepted and Unicode ellipsis characters in titles are normalized to three periods. A version value of 0 behaves like omission and selects the latest revision; other nonzero values select that exact revision. Redirect pages are returned as data with redirectTo rather than followed.
pub fn get_with(&self, wiki_category_id: impl Display, identifier: impl Display, query: &GetWikiCategoriesIdPagesIdentifierQuery) -> Result<models::WikiPage> {
let path = format!("/wiki/categories/{}/pages/{}", seg(wiki_category_id), seg(identifier));
let query: Query = query.to_query();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List wiki pages in a category
///
/// `GET /wiki/categories/{wikiCategoryId}/pages`
///
/// Lists the latest version of each non-system page in this category, including redirect pages. Requires churchwiki view category permission. Page text and previews are omitted. Results are ordered by display title (main uses the category name), then GUID, without pagination; meta.count is the number of returned pages. The nested wikiCategory.permissions object is normally empty, while page.permissions contains canEdit/canDelete.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-wiki-categories-id-pages");
/// for page in client.wiki().categories().pages().list(42)? {
/// println!("{}", page.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, wiki_category_id: impl Display) -> Result<Vec<models::SimpleWikiPage>> {
let path = format!("/wiki/categories/{}/pages", seg(wiki_category_id));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// Update a wiki page
///
/// `PATCH /wiki/categories/{wikiCategoryId}/pages/{identifier}`
///
/// Updates only supplied text, isMarkdown and onStartpage fields on the latest revision identified by GUID. Titles cannot be changed through this endpoint. Requires category edit permission; protected system pages in category 0 require a super administrator. Changed text creates the next revision with the same GUID; unchanged text or changes only to the flags modify the existing latest revision. Trimmed blank/null text clears the stored content. No expected-version or ETag precondition is accepted, so this endpoint does not provide optimistic edit-conflict protection.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("patch-wiki-categories-id-pages-identifier");
/// let body = models::WikiPageUpdate {
/// is_markdown: Some(true),
/// ..Default::default()
/// };
/// let result = client.wiki().categories().pages().patch(42, "681F54E3-2EB7-40A4-84F0-EFF8E8F05727", &body)?;
/// println!("{}", result.title);
/// # Ok(())
/// # }
/// ```
pub fn patch(&self, wiki_category_id: impl Display, identifier: impl Display, body: &models::WikiPageUpdate) -> Result<models::WikiPage> {
let path = format!("/wiki/categories/{}/pages/{}", seg(wiki_category_id), seg(identifier));
let query: Query = Query::new();
let body = serde_json::to_value(body).expect("request body serializes");
self.client.request_data(Method::Patch, &path, &query, Some(&body))
}
}
/// `client.wiki().categories().pages().versions()`
#[derive(Clone, Copy)]
pub struct WikiCategoriesPagesVersionsResource<'a> {
client: &'a Client,
}
impl<'a> WikiCategoriesPagesVersionsResource<'a> {
/// Get a specific version of a wiki page
///
/// `GET /wiki/categories/{wikiCategoryId}/pages/{identifier}/versions/{version}`
///
/// Requires churchwiki view category permission, including any permissions assigned to guests. For a protected system page in category 0, super-administrator access also permits the individual read. Returns one page revision with text: Markdown is returned as stored, legacy HTML is sanitized, and null content becomes an empty string. Prefer the stable page GUID; legacy titles are accepted and Unicode ellipsis characters in titles are normalized to three periods. A version value of 0 behaves like omission and selects the latest revision; other nonzero values select that exact revision. Redirect pages are returned as data with redirectTo rather than followed.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-wiki-categories-id-pages-id-versions-id");
/// let version = client.wiki().categories().pages().versions().get(42, "main", 1)?;
/// println!("{}", version.title);
/// # Ok(())
/// # }
/// ```
pub fn get(&self, wiki_category_id: impl Display, identifier: impl Display, version: impl Display) -> Result<models::WikiPage> {
let path = format!("/wiki/categories/{}/pages/{}/versions/{}", seg(wiki_category_id), seg(identifier), seg(version));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
/// List all versions of a wiki page
///
/// `GET /wiki/categories/{wikiCategoryId}/pages/{identifier}/versions`
///
/// Requires churchwiki view category permission, including any permissions assigned to guests. For a protected system page in category 0, super-administrator access also permits the individual read. Returns all revisions for the GUID or legacy title, newest version first, including each revision’s text. Missing pages return an empty list rather than 404. The list is not paginated; meta.count is the number of versions. Metadata and current permission hints are included for each revision. Title identifiers are deprecated for this history endpoint.
///
/// # Example
///
/// ```
/// # use churchtools_api::*;
/// # use churchtools_api::queries::*;
/// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
/// # let client = churchtools_api::replay::client("get-wiki-categories-id-pages-identifier-versions");
/// for version in client.wiki().categories().pages().versions().list(42, "main")? {
/// println!("{}", version.title);
/// }
/// # Ok(())
/// # }
/// ```
pub fn list(&self, wiki_category_id: impl Display, identifier: impl Display) -> Result<Vec<models::WikiPage>> {
let path = format!("/wiki/categories/{}/pages/{}/versions", seg(wiki_category_id), seg(identifier));
let query: Query = Query::new();
self.client.request_data(Method::Get, &path, &query, None)
}
}