Struct mailpot::Template

pub struct Template {
    pub pk: i64,
    pub name: String,
    pub list: Option<i64>,
    pub subject: Option<String>,
    pub headers_json: Option<Value>,
    pub body: String,
}

A named template.

Fields

pk: i64

Database primary key.

name: String

Name.

list: Option<i64>

Associated list foreign key, optional.

subject: Option<String>

Subject template.

headers_json: Option<Value>

Extra headers template.

body: String

Body template.

Implementations

impl Template

pub const GENERIC_HELP: &str = "generic-help"

Template name for generic list help e-mail.

pub const GENERIC_FAILURE: &str = "generic-failure"

Template name for generic failure e-mail.

pub const GENERIC_SUCCESS: &str = "generic-success"

Template name for generic success e-mail.

pub const SUBSCRIPTION_CONFIRMATION: &str = "subscription-confirmation"

Template name for subscription confirmation e-mail.

pub const UNSUBSCRIPTION_CONFIRMATION: &str = "unsubscription-confirmation"

Template name for unsubscription confirmation e-mail.

pub const SUBSCRIPTION_REQUEST_NOTICE_OWNER: &str = "subscription-notice-owner"

Template name for subscription request notice e-mail (for list owners).

pub const SUBSCRIPTION_REQUEST_CANDIDATE_ACCEPT: &str = "subscription-notice-candidate-accept"

Template name for subscription request acceptance e-mail (for the candidates).

pub const ADMIN_NOTICE: &str = "admin-notice"

Template name for admin notices.

pub fn render(&self, context: Value) -> Result<Draft>

Render a message body from a saved named template.

Examples found in repository

core/src/posts.rs (line 744)

    pub fn send_reply_with_list_template<'ctx, F: Fn() -> Template>(
        &self,
        render_context: TemplateRenderContext<'ctx, F>,
        recipients: impl Iterator<Item = Cow<'ctx, melib::Address>>,
    ) -> Result<()> {
        let TemplateRenderContext {
            template,
            default_fn,
            list,
            context,
            queue,
            comment,
        } = render_context;

        let post_policy = self.list_post_policy(list.pk)?;
        let subscription_policy = self.list_subscription_policy(list.pk)?;

        let templ = self
            .fetch_template(template, Some(list.pk))?
            .map(DbVal::into_inner)
            .or_else(|| default_fn.map(|f| f()))
            .ok_or_else(|| -> crate::Error {
                format!("Template with name {template:?} was not found.").into()
            })?;

        let mut draft = templ.render(context)?;
        draft.headers.insert(
            melib::HeaderName::new_unchecked("From"),
            list.request_subaddr(),
        );
        for addr in recipients {
            let mut draft = draft.clone();
            draft
                .headers
                .insert(melib::HeaderName::new_unchecked("To"), addr.to_string());
            list.insert_headers(
                &mut draft,
                post_policy.as_deref(),
                subscription_policy.as_deref(),
            );
            self.insert_to_queue(QueueEntry::new(
                queue,
                Some(list.pk),
                None,
                draft.finalise()?.as_bytes(),
                Some(comment.to_string()),
            )?)?;
        }
        Ok(())
    }

pub fn default_generic_failure() -> Self

Template name for generic failure e-mail.

pub fn default_generic_success() -> Self

Create a plain template for generic success e-mails.

pub fn default_subscription_confirmation() -> Self

Create a plain template for subscription confirmation.

pub fn default_unsubscription_confirmation() -> Self

Create a plain template for unsubscription confirmations.

pub fn default_admin_notice() -> Self

Create a plain template for admin notices.

pub fn default_subscription_request_owner() -> Self

Create a plain template for subscription requests for list owners.

pub fn default_subscription_request_candidate_accept() -> Self

Create a plain template for subscription requests for candidates.

pub fn default_generic_help() -> Self

Create a plain template for generic list help replies.

Trait Implementations

impl Clone for Template

fn clone(&self) -> Template

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Template

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Template

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Template

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<Template> for Template

fn eq(&self, other: &Template) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Template

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Template

impl StructuralEq for Template

impl StructuralPartialEq for Template