Struct mailpot::models::ListSubscription

pub struct ListSubscription {
    pub pk: i64,
    pub list: i64,
    pub address: String,
    pub name: Option<String>,
    pub account: Option<i64>,
    pub enabled: bool,
    pub verified: bool,
    pub digest: bool,
    pub hide_address: bool,
    pub receive_duplicates: bool,
    pub receive_own_posts: bool,
    pub receive_confirmation: bool,
}

A mailing list subscription entry.

Fields

pk: i64

Database primary key.

list: i64

Mailing list foreign key (See MailingList).

address: String

Subscription’s e-mail address.

name: Option<String>

Subscription’s name, optional.

account: Option<i64>

Subscription’s account foreign key, optional.

enabled: bool

Whether this subscription is enabled.

verified: bool

Whether the e-mail address is verified.

digest: bool

Whether subscription wishes to receive list posts as a periodical digest e-mail.

hide_address: bool

Whether subscription wishes their e-mail address hidden from public view.

receive_duplicates: bool

Whether subscription wishes to receive mailing list post duplicates, i.e. posts addressed to them and the mailing list to which they are subscribed.

receive_own_posts: bool

Whether subscription wishes to receive their own mailing list posts from the mailing list, as a confirmation.

receive_confirmation: bool

Whether subscription wishes to receive a plain confirmation for their own mailing list posts.

Implementations

impl ListSubscription

pub fn address(&self) -> Address

Subscription address as a [melib::Address]

Examples found in repository

core/src/models.rs (line 519)

    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(
            fmt,
            "{} [digest: {}, hide_address: {} verified: {} {}]",
            self.address(),
            self.digest,
            self.hide_address,
            self.verified,
            if self.enabled {
                "enabled"
            } else {
                "not enabled"
            },
        )
    }

core/src/message_filters.rs (line 360)

    fn feed<'p, 'list>(
        self: Box<Self>,
        post: &'p mut PostEntry,
        ctx: &'p mut ListContext<'list>,
    ) -> std::result::Result<(&'p mut PostEntry, &'p mut ListContext<'list>), ()> {
        trace!("Running FinalizeRecipients filter");
        let mut recipients = vec![];
        let mut digests = vec![];
        let email_from = post.from.get_email();
        for subscription in ctx.subscriptions {
            trace!("examining subscription {:?}", &subscription);
            if subscription.address == email_from {
                trace!("subscription is submitter");
            }
            if subscription.digest {
                if subscription.address != email_from || subscription.receive_own_posts {
                    trace!("Subscription gets digest");
                    digests.push(subscription.address());
                }
                continue;
            }
            if subscription.address != email_from || subscription.receive_own_posts {
                trace!("Subscription gets copy");
                recipients.push(subscription.address());
            }
        }
        ctx.scheduled_jobs.push(MailJob::Send { recipients });
        if !digests.is_empty() {
            ctx.scheduled_jobs.push(MailJob::StoreDigest {
                recipients: digests,
            });
        }
        post.action = PostAction::Accept;
        Ok((post, ctx))
    }

Trait Implementations

impl Clone for ListSubscription

fn clone(&self) -> ListSubscription

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ListSubscription

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ListSubscription

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

Deserialize this value from the given Serde deserializer.

impl Display for ListSubscription

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

Formats the value using the given formatter.

impl From<ListOwner> for ListSubscription

fn from(val: ListOwner) -> Self

Converts to this type from the input type.

impl PartialEq<ListSubscription> for ListSubscription

fn eq(&self, other: &ListSubscription) -> 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 ListSubscription

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 ListSubscription

impl StructuralEq for ListSubscription

impl StructuralPartialEq for ListSubscription