use std::sync::Arc;
use serde::Serialize;
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::Result;
use crate::core::models::message_template::{
MessageTemplateContent, MessageTemplateDetail, MessageTemplateLanguage, MessageTemplateList,
MessageTemplatePreview, SendTestMessageResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
use crate::resources::buyer_portal::check_extra;
#[derive(Debug, Clone)]
pub struct MessageTemplates {
inner: Arc<Inner>,
}
impl MessageTemplates {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn list_shop(&self, profile_id: &str) -> Result<MessageTemplateList> {
let path = shop_path(profile_id);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn retrieve_shop(
&self,
profile_id: &str,
template_id: &str,
) -> Result<MessageTemplateDetail> {
let path = template_path(profile_id, template_id);
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update_shop_language(
&self,
profile_id: &str,
template_id: &str,
language: &str,
params: &MessageTemplateLanguageUpdateRequest,
) -> Result<MessageTemplateLanguage> {
params.validate()?;
let path = language_path(profile_id, template_id, language);
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn reset_shop_language(
&self,
profile_id: &str,
template_id: &str,
language: &str,
expected_revision: Option<i64>,
) -> Result<MessageTemplateLanguage> {
let path = language_path(profile_id, template_id, language);
let query = match expected_revision {
Some(revision) => vec![("expected_revision", revision.to_string())],
None => Vec::new(),
};
self.inner
.request_body_keyed_with_query(HttpMethod::Delete, &path, None, &query, None)
.await
}
pub async fn preview_shop(
&self,
profile_id: &str,
template_id: &str,
params: &MessageTemplatePreviewRequest,
) -> Result<MessageTemplatePreview> {
params.validate()?;
let path = format!("{}/preview", template_path(profile_id, template_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn send_shop_test(
&self,
profile_id: &str,
template_id: &str,
params: &SendTestMessageRequest,
) -> Result<SendTestMessageResponse> {
params.validate()?;
let path = format!("{}/test", template_path(profile_id, template_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
}
fn shop_path(profile_id: &str) -> String {
format!("/message-templates/shops/{}", encode_segment(profile_id))
}
fn template_path(profile_id: &str, template_id: &str) -> String {
format!("{}/{}", shop_path(profile_id), encode_segment(template_id))
}
fn language_path(profile_id: &str, template_id: &str, language: &str) -> String {
format!(
"{}/languages/{}",
template_path(profile_id, template_id),
encode_segment(language)
)
}
#[derive(Debug, Clone, Serialize)]
pub struct MessageTemplateLanguageUpdateRequest {
pub content: MessageTemplateContent,
#[serde(skip_serializing_if = "Option::is_none")]
pub expected_revision: Option<i64>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl MessageTemplateLanguageUpdateRequest {
pub fn new(content: MessageTemplateContent) -> Self {
Self {
content,
expected_revision: None,
extra: serde_json::Map::new(),
}
}
#[must_use]
pub fn expected_revision(mut self, revision: i64) -> Self {
self.expected_revision = Some(revision);
self
}
}
const MESSAGE_TEMPLATE_LANGUAGE_UPDATE_REQUEST_NAMED: &[&str] = &["content", "expected_revision"];
impl ValidateRequest for MessageTemplateLanguageUpdateRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
MESSAGE_TEMPLATE_LANGUAGE_UPDATE_REQUEST_NAMED,
"MessageTemplateLanguageUpdateRequest",
)
}
}
#[derive(Debug, Clone, Serialize)]
pub struct MessageTemplatePreviewRequest {
pub language: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<MessageTemplateContent>,
#[serde(skip_serializing_if = "Option::is_none")]
pub keep_placeholders: Option<bool>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl MessageTemplatePreviewRequest {
pub fn new(language: impl Into<String>) -> Self {
Self {
language: language.into(),
content: None,
keep_placeholders: None,
extra: serde_json::Map::new(),
}
}
#[must_use]
pub fn content(mut self, content: MessageTemplateContent) -> Self {
self.content = Some(content);
self
}
#[must_use]
pub fn keep_placeholders(mut self, keep: bool) -> Self {
self.keep_placeholders = Some(keep);
self
}
}
const MESSAGE_TEMPLATE_PREVIEW_REQUEST_NAMED: &[&str] =
&["language", "content", "keep_placeholders"];
impl ValidateRequest for MessageTemplatePreviewRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
MESSAGE_TEMPLATE_PREVIEW_REQUEST_NAMED,
"MessageTemplatePreviewRequest",
)
}
}
#[derive(Debug, Clone, Serialize)]
pub struct SendTestMessageRequest {
pub language: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<MessageTemplateContent>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl SendTestMessageRequest {
pub fn new(language: impl Into<String>) -> Self {
Self {
language: language.into(),
content: None,
extra: serde_json::Map::new(),
}
}
#[must_use]
pub fn content(mut self, content: MessageTemplateContent) -> Self {
self.content = Some(content);
self
}
}
const SEND_TEST_MESSAGE_REQUEST_NAMED: &[&str] = &["language", "content"];
impl ValidateRequest for SendTestMessageRequest {
fn validate(&self) -> Result<()> {
check_extra(
&self.extra,
SEND_TEST_MESSAGE_REQUEST_NAMED,
"SendTestMessageRequest",
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::error::DelopayError;
use crate::core::models::message_template::{MessageTemplateHtml, MessageTemplateLayout};
use crate::http::mock::{Step, client_with};
use serde_json::json;
const LANGUAGE_JSON: &str = r#"{
"language": "de",
"own": {
"content": {"mode": "html", "subject": "Rechnung", "html": "<p>Hallo</p>"},
"revision": 3, "updated_at": "2026-01-01T00:00:00Z",
"updated_by": {"id": "usr_1", "name": "Sam"}
},
"inherited": {
"content": {"mode": "layout", "subject": "Invoice", "preheader": null,
"heading": "Your invoice", "body": "See attached",
"action_label": null, "footer": null},
"source": "built_in"
},
"built_in": {"mode": "layout", "subject": "Invoice", "preheader": null,
"heading": null, "body": "See attached", "action_label": null,
"footer": null},
"effective_source": "shop",
"surprise_field": 1
}"#;
#[tokio::test]
async fn list_shop_gets_the_shop_list_with_the_dashboard_token() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"scope":"shop","scope_id":"pro_1","languages":["en","de"],
"default_language":"en",
"templates":[{"id":"invoice_issued","channel":"email","audience":"buyer",
"editable_scopes":["platform","shop"],"action_variable":"invoice_url",
"action_required":false,
"languages":[{"language":"en","source":"built_in","mode":"layout"}],
"customised_languages":[],"shops_customised":null}],
"surprise_field":1}"#,
)]);
let list = client
.with_jwt("jwt_1")
.message_templates()
.list_shop("pro/1")
.await
.unwrap();
assert_eq!(list.scope, "shop");
assert_eq!(list.templates[0].languages[0].source, "built_in");
assert_eq!(list.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/message-templates/shops/pro%2F1"
);
assert_eq!(seen[0].header("authorization"), Some("Bearer jwt_1"));
assert_eq!(seen[0].header("api-key"), None);
}
#[tokio::test]
async fn retrieve_shop_decodes_both_content_modes() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"id":"invoice_issued","channel":"email","audience":"buyer",
"editable_scopes":["shop"],"action_variable":null,"action_required":false,
"variables":[{{"name":"invoice_url","alias":"link","required":true,
"sample":"https://x"}}],
"languages":[{LANGUAGE_JSON}],"surprise_field":2}}"#
))]);
let detail = client
.message_templates()
.retrieve_shop("pro_1", "invoice_issued")
.await
.unwrap();
assert!(detail.variables[0].required);
let language = &detail.languages[0];
assert_eq!(language.own.as_ref().unwrap().revision, 3);
assert_eq!(
language.own.as_ref().unwrap().content,
MessageTemplateContent::Html(MessageTemplateHtml::new("Rechnung", "<p>Hallo</p>"))
);
assert_eq!(
language.inherited.content,
MessageTemplateContent::Layout(
MessageTemplateLayout::new("Invoice", "See attached").heading("Your invoice")
)
);
assert_eq!(language.extra["surprise_field"], 1);
assert_eq!(detail.extra["surprise_field"], 2);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/message-templates/shops/pro_1/invoice_issued"
);
}
#[tokio::test]
async fn update_shop_language_puts_the_tagged_content() {
let (client, mock) = client_with(vec![Step::ok(LANGUAGE_JSON)]);
let content = MessageTemplateContent::Layout(
MessageTemplateLayout::new("Rechnung", "Anbei")
.heading("Ihre Rechnung")
.action_label("Ansehen"),
);
let params = MessageTemplateLanguageUpdateRequest::new(content).expected_revision(0);
let out = client
.message_templates()
.update_shop_language("pro_1", "invoice_issued", "de", ¶ms)
.await
.unwrap();
assert_eq!(out.effective_source, "shop");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/message-templates/shops/pro_1/invoice_issued/languages/de"
);
assert_eq!(
seen[0].body_json(),
json!({
"content": {
"mode": "layout",
"subject": "Rechnung",
"preheader": null,
"heading": "Ihre Rechnung",
"body": "Anbei",
"action_label": "Ansehen",
"footer": null
},
"expected_revision": 0
})
);
}
#[tokio::test]
async fn reset_shop_language_deletes_with_the_revision_query() {
let (client, mock) = client_with(vec![Step::ok(LANGUAGE_JSON), Step::ok(LANGUAGE_JSON)]);
let templates = client.message_templates();
templates
.reset_shop_language("pro_1", "invoice_issued", "de", Some(3))
.await
.unwrap();
templates
.reset_shop_language("pro_1", "invoice_issued", "de", None)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/message-templates/shops/pro_1/invoice_issued/languages/de?expected_revision=3"
);
assert_eq!(
seen[1].url,
"https://api.test/message-templates/shops/pro_1/invoice_issued/languages/de"
);
}
#[tokio::test]
async fn preview_shop_posts_the_draft() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"language":"en","subject":"Invoice","html":"<p>x</p>","text":"x",
"warnings":["missing link"],"surprise_field":1}"#,
)]);
let params = MessageTemplatePreviewRequest::new("en")
.content(MessageTemplateContent::Html(MessageTemplateHtml::new(
"Invoice", "<p>x</p>",
)))
.keep_placeholders(false);
let preview = client
.message_templates()
.preview_shop("pro_1", "invoice_issued", ¶ms)
.await
.unwrap();
assert_eq!(preview.warnings, ["missing link"]);
assert_eq!(preview.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/message-templates/shops/pro_1/invoice_issued/preview"
);
assert_eq!(
seen[0].body_json(),
json!({
"language": "en",
"content": {"mode": "html", "subject": "Invoice", "html": "<p>x</p>"},
"keep_placeholders": false
})
);
}
#[tokio::test]
async fn send_shop_test_posts_the_language_and_redacts_the_address() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"sent_to":"sam@example.com","surprise_field":1}"#,
)]);
let out = client
.message_templates()
.send_shop_test(
"pro_1",
"invoice_issued",
&SendTestMessageRequest::new("en"),
)
.await
.unwrap();
assert_eq!(out.sent_to, "sam@example.com");
assert_eq!(out.extra["surprise_field"], 1);
assert!(!format!("{out:?}").contains("sam@example.com"));
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/message-templates/shops/pro_1/invoice_issued/test"
);
assert_eq!(seen[0].body_json(), json!({"language": "en"}));
assert!(!seen[0].had_idempotency_key());
}
#[test]
fn update_validate_rejects_a_colliding_extra_key() {
let mut req = MessageTemplateLanguageUpdateRequest::new(MessageTemplateContent::Html(
MessageTemplateHtml::new("s", "h"),
));
req.extra.insert("content".to_string(), json!({}));
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("content")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
fn assert_named_covers(value: Value, named: &[&str], const_name: &str) {
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
named.contains(&key.as_str()),
"{const_name} is missing wire key `{key}`"
);
}
}
#[test]
fn message_template_language_update_request_named_fields_are_complete() {
let req = MessageTemplateLanguageUpdateRequest::new(MessageTemplateContent::Html(
MessageTemplateHtml::new("s", "h"),
))
.expected_revision(1);
assert_named_covers(
serde_json::to_value(req).unwrap(),
MESSAGE_TEMPLATE_LANGUAGE_UPDATE_REQUEST_NAMED,
"MESSAGE_TEMPLATE_LANGUAGE_UPDATE_REQUEST_NAMED",
);
}
#[test]
fn message_template_preview_request_named_fields_are_complete() {
let req = MessageTemplatePreviewRequest::new("en")
.content(MessageTemplateContent::Html(MessageTemplateHtml::new(
"s", "h",
)))
.keep_placeholders(true);
assert_named_covers(
serde_json::to_value(req).unwrap(),
MESSAGE_TEMPLATE_PREVIEW_REQUEST_NAMED,
"MESSAGE_TEMPLATE_PREVIEW_REQUEST_NAMED",
);
}
#[test]
fn send_test_message_request_named_fields_are_complete() {
let req = SendTestMessageRequest::new("en").content(MessageTemplateContent::Html(
MessageTemplateHtml::new("s", "h"),
));
assert_named_covers(
serde_json::to_value(req).unwrap(),
SEND_TEST_MESSAGE_REQUEST_NAMED,
"SEND_TEST_MESSAGE_REQUEST_NAMED",
);
}
fn keyed_client(
ok: &str,
) -> (
crate::Delopay,
std::sync::Arc<crate::http::mock::MockTransport>,
) {
let (client, mock) = crate::http::mock::client_with_retries(
vec![
Step::status(503, r#"{"error":{"message":"down"}}"#),
Step::ok(ok),
],
2,
);
(client.with_idempotency_key("idem_client_wide"), mock)
}
fn assert_sent_once_without_key(mock: &crate::http::mock::MockTransport) {
assert_eq!(
mock.call_count(),
1,
"a 503 on this write must not be retried"
);
assert!(
!mock.seen.lock().unwrap()[0].had_idempotency_key(),
"the client-wide key must not be sent"
);
}
#[tokio::test]
async fn template_writes_ignore_the_client_wide_idempotency_key() {
let (client, mock) = keyed_client(r#"{"sent_to":"sam@example.com"}"#);
assert!(
client
.message_templates()
.send_shop_test(
"pro_1",
"invoice_issued",
&SendTestMessageRequest::new("en")
)
.await
.is_err()
);
assert_sent_once_without_key(&mock);
let (client, mock) = keyed_client(LANGUAGE_JSON);
let params = MessageTemplateLanguageUpdateRequest::new(MessageTemplateContent::Html(
MessageTemplateHtml::new("s", "h"),
));
assert!(
client
.message_templates()
.update_shop_language("pro_1", "invoice_issued", "de", ¶ms)
.await
.is_err()
);
assert_sent_once_without_key(&mock);
let (client, mock) = keyed_client(LANGUAGE_JSON);
assert!(
client
.message_templates()
.reset_shop_language("pro_1", "invoice_issued", "de", None)
.await
.is_err()
);
assert_sent_once_without_key(&mock);
let (client, mock) =
keyed_client(r#"{"language":"en","subject":"s","html":"h","text":"t","warnings":[]}"#);
assert!(
client
.message_templates()
.preview_shop(
"pro_1",
"invoice_issued",
&MessageTemplatePreviewRequest::new("en")
)
.await
.is_err()
);
assert_sent_once_without_key(&mock);
}
}