8 posts tagged with "email"

        // Build a simple multipart message
        let message = MessageBuilder::new()
            .from(("John Doe", "[email protected]"))
            .to(vec![
                ("Jane Doe", "[email protected]"),
                ("James Smith", "[email protected]"),
            ])
            .subject("Hi!")
            .html_body("<h1>Hello, world!</h1>")
            .text_body("Hello world!");
    
        // Connect to an SMTP relay server over TLS and
        // authenticate using the provided credentials.
        Transport::new("smtp.gmail.com")
            .credentials("john", "p4ssw0rd")
            .connect_tls()
            .await
            .unwrap()
            .send(message)
            .await
            .unwrap();

    // Build a simple text message with a single attachment
        let message = MessageBuilder::new()
            .from(("John Doe", "[email protected]"))
            .to("[email protected]")
            .subject("Howdy!")
            .text_body("These pretzels are making me thirsty.")
            .binary_attachment("image/png", "pretzels.png", [1, 2, 3, 4].as_ref());
    
        // Set up DKIM signer
        let dkim = DKIM::from_pkcs1_pem_file("./cert.pem")
            .unwrap()
            .domain("example.com")
            .selector("2022")
            .headers(["From", "To", "Subject"]) // Headers to sign
            .expiration(60 * 60 * 7); // Number of seconds before this signature expires (optional)
    
        // Connect to an SMTP relay server over TLS.
        // Signs each message with the configured DKIM signer.
        Transport::new("smtp.example.com")
            .dkim(dkim)
            .connect_tls()
            .await
            .unwrap()
            .send(message)
            .await
            .unwrap();

        // Build a simple text message with a single attachment
        let mut message = MessageBuilder::new();
        message.from(("John Doe", "[email protected]"));
        message.to("[email protected]");
        message.subject("Hello, world!");
        message.text_body("Message contents go here.");
        message.binary_attachment("image/png", "image.png", &[1, 2, 3, 4]);

        // Write message to memory
        let mut output = Vec::new();
        message.write_to(&mut output).unwrap();

        // Build a multipart message with text and HTML bodies,
        // inline parts and attachments.
        let mut message = MessageBuilder::new();
        message.from(("John Doe", "[email protected]"));

        // To recipients
        message.to(vec![
            ("Antoine de Saint-Exupéry", "[email protected]"),
            ("안녕하세요 세계", "[email protected]"),
            ("Xin chào", "[email protected]"),
        ]);

        // BCC recipients using grouped addresses
        message.bcc(vec![
            (
                "My Group",
                vec![
                    ("ASCII name", "[email protected]"),
                    ("ハロー・ワールド", "[email protected]"),
                    ("áéíóú", "[email protected]"),
                    ("Γειά σου Κόσμε", "[email protected]"),
                ],
            ),
            (
                "Another Group",
                vec![
                    ("שלום עולם", "[email protected]"),
                    ("ñandú come ñoquis", "[email protected]"),
                    ("Recipient", "[email protected]"),
                ],
            ),
        ]);

        // Set RFC and custom headers
        message.subject("Testing multipart messages");
        message.in_reply_to(vec!["message-id-1", "message-id-2"]);
        message.header("List-Archive", URL::new("http://example.com/archive"));

        // Set HTML and plain text bodies
        message.text_body("This is the text body!\n");
        message.html_body("<p>HTML body with <img src=\"cid:my-image\"/>!</p>");

        // Include an embedded image as an inline part
        message.binary_inline("image/png", "cid:my-image", &[0, 1, 2, 3, 4, 5]);

        // Add a text and a binary attachment
        message.text_attachment("text/plain", "my fíle.txt", "Attachment contents go here.");
        message.binary_attachment(
            "text/plain",
            "ハロー・ワールド",
            b"Binary contents go here.",
        );

        // Write the message to a file
        message
            .write_to(File::create("message.eml").unwrap())
            .unwrap();

    // Build a nested multipart message
        let mut message = MessageBuilder::new();

        message.from(Address::new_address("John Doe".into(), "[email protected]"));
        message.to(Address::new_address("Jane Doe".into(), "[email protected]"));
        message.subject("Nested multipart message");

        // Define the nested MIME body structure
        message.body(MimePart::new_multipart(
            "multipart/mixed",
            vec![
                MimePart::new_text("Part A contents go here...").inline(),
                MimePart::new_multipart(
                    "multipart/mixed",
                    vec![
                        MimePart::new_multipart(
                            "multipart/alternative",
                            vec![
                                MimePart::new_multipart(
                                    "multipart/mixed",
                                    vec![
                                        MimePart::new_text("Part B contents go here...").inline(),
                                        MimePart::new_binary(
                                            "image/jpeg",
                                            "Part C contents go here...".as_bytes(),
                                        )
                                        .inline(),
                                        MimePart::new_text("Part D contents go here...").inline(),
                                    ],
                                ),
                                MimePart::new_multipart(
                                    "multipart/related",
                                    vec![
                                        MimePart::new_html("Part E contents go here...").inline(),
                                        MimePart::new_binary(
                                            "image/jpeg",
                                            "Part F contents go here...".as_bytes(),
                                        ),
                                    ],
                                ),
                            ],
                        ),
                        MimePart::new_binary("image/jpeg", "Part G contents go here...".as_bytes())
                            .attachment("image_G.jpg"),
                        MimePart::new_binary(
                            "application/x-excel",
                            "Part H contents go here...".as_bytes(),
                        ),
                        MimePart::new_binary(
                            "x-message/rfc822",
                            "Part J contents go here...".as_bytes(),
                        ),
                    ],
                ),
                MimePart::new_text("Part K contents go here...").inline(),
            ],
        ));

        // Write the message to a file
        message
            .write_to(File::create("nested-message.eml").unwrap())
            .unwrap();

    let input = concat!(
            "From: Art Vandelay <[email protected]> (Vandelay Industries)\n",
            "To: \"Colleagues\": \"James Smythe\" <[email protected]>; Friends:\n",
            "    [email protected], =?UTF-8?Q?John_Sm=C3=AEth?= <[email protected]>;\n",
            "Date: Sat, 20 Nov 2021 14:22:01 -0800\n",
            "Subject: Why not both importing AND exporting? =?utf-8?b?4pi6?=\n",
            "Content-Type: multipart/mixed; boundary=\"festivus\";\n\n",
            "--festivus\n",
            "Content-Type: text/html; charset=\"us-ascii\"\n",
            "Content-Transfer-Encoding: base64\n\n",
            "PGh0bWw+PHA+SSB3YXMgdGhpbmtpbmcgYWJvdXQgcXVpdHRpbmcgdGhlICZsZHF1bztle\n",
            "HBvcnRpbmcmcmRxdW87IHRvIGZvY3VzIGp1c3Qgb24gdGhlICZsZHF1bztpbXBvcnRpbm\n",
            "cmcmRxdW87LDwvcD48cD5idXQgdGhlbiBJIHRob3VnaHQsIHdoeSBub3QgZG8gYm90aD8\n",
            "gJiN4MjYzQTs8L3A+PC9odG1sPg==\n",
            "--festivus\n",
            "Content-Type: message/rfc822\n\n",
            "From: \"Cosmo Kramer\" <[email protected]>\n",
            "Subject: Exporting my book about coffee tables\n",
            "Content-Type: multipart/mixed; boundary=\"giddyup\";\n\n",
            "--giddyup\n",
            "Content-Type: text/plain; charset=\"utf-16\"\n",
            "Content-Transfer-Encoding: quoted-printable\n\n",
            "=FF=FE=0C!5=D8\"=DD5=D8)=DD5=D8-=DD =005=D8*=DD5=D8\"=DD =005=D8\"=\n",
            "=DD5=D85=DD5=D8-=DD5=D8,=DD5=D8/=DD5=D81=DD =005=D8*=DD5=D86=DD =\n",
            "=005=D8=1F=DD5=D8,=DD5=D8,=DD5=D8(=DD =005=D8-=DD5=D8)=DD5=D8\"=\n",
            "=DD5=D8=1E=DD5=D80=DD5=D8\"=DD!=00\n",
            "--giddyup\n",
            "Content-Type: image/gif; name*1=\"about \"; name*0=\"Book \";\n",
            "              name*2*=utf-8''%e2%98%95 tables.gif\n",
            "Content-Transfer-Encoding: Base64\n",
            "Content-Disposition: attachment\n\n",
            "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7\n",
            "--giddyup--\n",
            "--festivus--\n",
        )
        .as_bytes();
    
        let message = Message::parse(input);
    
        // Parses addresses (including comments), lists and groups
        assert_eq!(
            message.get_from(),
            &Address::Address(Addr {
                name: Some("Art Vandelay (Vandelay Industries)".into()),
                address: Some("[email protected]".into())
            })
        );
        assert_eq!(
            message.get_to(),
            &Address::GroupList(vec![
                Group {
                    name: Some("Colleagues".into()),
                    addresses: vec![Addr {
                        name: Some("James Smythe".into()),
                        address: Some("[email protected]".into())
                    }]
                },
                Group {
                    name: Some("Friends".into()),
                    addresses: vec![
                        Addr {
                            name: None,
                            address: Some("[email protected]".into())
                        },
                        Addr {
                            name: Some("John Smîth".into()),
                            address: Some("[email protected]".into())
                        }
                    ]
                }
            ])
        );
    
        assert_eq!(
            message.get_date().unwrap().to_iso8601(),
            "2021-11-20T14:22:01-08:00"
        );
    
        // RFC2047 support for encoded text in message readers
        assert_eq!(
            message.get_subject().unwrap(),
            "Why not both importing AND exporting? ☺"
        );
    
        // HTML and text body parts are returned conforming to RFC8621, Section 4.1.4 
        assert_eq!(
            message.get_html_body(0).unwrap().to_string(),
            concat!(
                "<html><p>I was thinking about quitting the &ldquo;exporting&rdquo; to ",
                "focus just on the &ldquo;importing&rdquo;,</p><p>but then I thought,",
                " why not do both? &#x263A;</p></html>"
            )
        );
    
        // HTML parts are converted to plain text (and viceversa) when missing
        assert_eq!(
            message.get_text_body(0).unwrap().to_string(),
            concat!(
                "I was thinking about quitting the “exporting” to focus just on the",
                " “importing”,\nbut then I thought, why not do both? ☺\n"
            )
        );
    
        // Supports nested messages as well as multipart/digest
        let nested_message = match message.get_attachment(0).unwrap() {
            MessagePart::Message(v) => v,
            _ => unreachable!(),
        };
    
        assert_eq!(
            nested_message.get_subject().unwrap(),
            "Exporting my book about coffee tables"
        );
    
        // Handles UTF-* as well as many legacy encodings
        assert_eq!(
            nested_message.get_text_body(0).unwrap().to_string(),
            "ℌ𝔢𝔩𝔭 𝔪𝔢 𝔢𝔵𝔭𝔬𝔯𝔱 𝔪𝔶 𝔟𝔬𝔬𝔨 𝔭𝔩𝔢𝔞𝔰𝔢!"
        );
        assert_eq!(
            nested_message.get_html_body(0).unwrap().to_string(),
            "<html><body>ℌ𝔢𝔩𝔭 𝔪𝔢 𝔢𝔵𝔭𝔬𝔯𝔱 𝔪𝔶 𝔟𝔬𝔬𝔨 𝔭𝔩𝔢𝔞𝔰𝔢!</body></html>"
        );
    
        let nested_attachment = match nested_message.get_attachment(0).unwrap() {
            MessagePart::Binary(v) => v,
            _ => unreachable!(),
        };
    
        assert_eq!(nested_attachment.len(), 42);
    
        // Full RFC2231 support for continuations and character sets
        assert_eq!(
            nested_attachment
                .get_header()
                .unwrap()
                .get_content_type()
                .unwrap()
                .get_attribute("name")
                .unwrap(),
            "Book about ☕ tables.gif"
        );
    
        // Integrates with Serde
        println!("{}", serde_json::to_string_pretty(&message).unwrap());
        println!("{}", serde_yaml::to_string(&message).unwrap());