Xpages：使用后端文档通过 java 发送 html 电子邮件

Question

我发现了这个很棒的 Java Bean，它允许您通过 managed java bean 发送包含附件的 html 电子邮件。当我直接使用它形成 Xpage 时，它的工作原理与描述的一样。

但是，我想在预定代理的后端使用它。我遇到运行的问题是当我尝试将文档传递给 java bean 时。该 bean 需要（我认为）一个 XSP 文档，而我在后端没有它，所以它会抛出一个错误。

我以为我会发送我想要的文档的 UNID，然后更改它以便它可以与这个 bean 一起使用，但是，当我尝试设置 UNID 时，我收到错误消息：

Unknown member 'setUNID' in Java class 'com.scoular.utls.Email'

我很困惑。好像跟wrapped document有关系，但是不懂

这是面孔配置：

<faces-config>
  <managed-bean>
    <managed-bean-name>Email</managed-bean-name>
    <managed-bean-class>com.scoular.utls.Email</managed-bean-class>
    <managed-bean-scope>request</managed-bean-scope>
    <managed-property>
      <property-name>debugMode</property-name>
      <value>true</value>
    </managed-property>
  </managed-bean>
</faces-config>

这是我用来测试调用方法的按钮：

//Need to get email document 
var emlView = database.getView("xpViewEmailsAll");
var emlDoc = emlView.getFirstDocument();
if (emlDoc != null) {


//try{
    var subject = ""       
    var senderEmail = supEml
    var senderName = supNme

    Email.setSendTo("John");
    Email.setSubject("subject");
    Email.setSenderEmail("John@gmal.com");
    Email.setUNID = emlDoc.getUniversalID();
    Email.setSenderName("Sender");
    //Email.setBackEndDocument(emlDoc);
    Email.setFieldName("Body");
    Email.send();
//}catch(e){
    //print(e.getMessage());
//}
}

这是豆子：

package com.scoular.utls;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.faces.context.FacesContext;

import lotus.domino.Database;
import lotus.domino.Document;
import lotus.domino.EmbeddedObject;
import lotus.domino.MIMEEntity;
import lotus.domino.MIMEHeader;
import lotus.domino.NotesException;
import lotus.domino.Session;
import lotus.domino.Stream;

import com.ibm.commons.util.NotImplementedException;
import com.ibm.domino.xsp.module.nsf.NotesContext;
import com.ibm.xsp.model.FileRowData;
import com.ibm.xsp.model.domino.wrapped.DominoDocument;
import com.ibm.xsp.model.domino.wrapped.DominoRichTextItem;
import com.ibm.xsp.model.domino.wrapped.DominoDocument.AttachmentValueHolder;
import com.ibm.xsp.persistence.PersistedContent;

public class Email {

    private ArrayList<String> sendTo;
    private ArrayList<String> ccList;
    private ArrayList<String> bccList;
    private String senderEmail;
    private String senderName;
    private String subject;
    private DominoDocument document;
    private String fieldName;
    private String bannerHTML;
    private String footerHTML;
    private String unid;
    private boolean debugMode = false;
    private static final Pattern imgRegExp = Pattern.compile("<img[^>]+src\s*=\s*['\"]([^'\"]+)['\"][^>]*>");

    // -------------------------------------------------------------------------

    public Email() {
        this.subject = "";
        this.sendTo = new ArrayList<String>();
        this.ccList = new ArrayList<String>();
        this.bccList = new ArrayList<String>();
    }

    // -------------------------------------------------------------------------

    public String getSendTo() {
        if (this.isDebugMode()) {
            System.out.println("getSendTo() : " + this.sendTo.toString());
        }
        return this.sendTo.toString().replace("[", "").replace("]", "");
    }

    public void setSendTo(final String sendTo) {
        this.sendTo.add(sendTo);
    }

    // -------------------------------------------------------------------------

    public String getCcList() {
        if (this.isDebugMode()) {
            System.out.println("getCcList() : " + this.ccList.toString());
        }
        return this.ccList.toString().replace("[", "").replace("]", "");
    }

    public void setCcList(final String ccList) {
        this.ccList.add(ccList);
    }

    // -------------------------------------------------------------------------

    public String getBccList() {
        if (this.isDebugMode()) {
            System.out.println("getBccList() : " + this.bccList.toString());
        }
        return this.bccList.toString().replace("[", "").replace("]", "");
    }

    public void setBccList(final String bccList) {
        this.bccList.add(bccList);
    }

    // -------------------------------------------------------------------------

    public String getSenderEmail() {
        return this.senderEmail;
    }

    public void setSenderEmail(final String senderEmail) {
        this.senderEmail = senderEmail;
    }

    // -------------------------------------------------------------------------

    public String getSenderName() {
        return this.senderName;
    }

    public void setSenderName(final String senderName) {
        this.senderName = senderName;
    }

    // -------------------------------------------------------------------------

    public String getSubject() {
        return this.subject;
    }

    public void setSubject(final String subject) {
        this.subject = subject;
    }

    // -------------------------------------------------------------------------

    public boolean isDebugMode() {
        return this.debugMode;
    }

    public void setDebugMode(final boolean debugMode) {
        this.debugMode = debugMode;
    }

    // -------------------------------------------------------------------------

    private Session getCurrentSession() {
        NotesContext nc = NotesContext.getCurrentUnchecked();
        return (null != nc) ? nc.getCurrentSession() : null;
    }

    // -------------------------------------------------------------------------

    private Database getCurrentDatabase() {
        NotesContext nc = NotesContext.getCurrentUnchecked();
        return (null != nc) ? nc.getCurrentDatabase() : null;
    }

    // -------------------------------------------------------------------------

    public void send() throws NotesException, IOException, Exception {
        Session session = getCurrentSession();
        Database database = getCurrentDatabase();
        if (null != session && null != database && null != this.sendTo && null != this.subject
                && null != this.senderEmail) {
            try {
                if (this.isDebugMode()) {
                    System.out.println("Started send()");
                }
                session.setConvertMime(false);
                Document emailDocument = database.createDocument();

                MIMEEntity emailRoot = emailDocument.createMIMEEntity("Body");
                if (null != emailRoot) {
                    MIMEHeader emailHeader = emailRoot.createHeader("Reply-To");
                    emailHeader.setHeaderVal(this.getSenderEmail());

                    emailHeader = emailRoot.createHeader("Return-Path");
                    emailHeader.setHeaderVal(this.getSenderEmail());

                    final String fromSender = (null == this.getSenderName()) ? this.getSenderEmail() : "\""
                            + this.getSenderName() + "\" <" + this.getSenderEmail() + ">";

                    emailHeader = emailRoot.createHeader("From");
                    emailHeader.setHeaderVal(fromSender);

                    emailHeader = emailRoot.createHeader("Sender");
                    emailHeader.setHeaderVal(fromSender);

                    emailHeader = emailRoot.createHeader("To");
                    emailHeader.setHeaderVal(this.getSendTo());

                    if (!this.ccList.isEmpty()) {
                        emailHeader = emailRoot.createHeader("CC");
                        emailHeader.setHeaderVal(this.getCcList());
                    }

                    if (!this.bccList.isEmpty()) {
                        emailHeader = emailRoot.createHeader("BCC");
                        emailHeader.setHeaderVal(this.getBccList());
                    }

                    emailHeader = emailRoot.createHeader("Subject");
                    emailHeader.setHeaderVal(this.getSubject());

                    MIMEEntity emailRootChild = emailRoot.createChildEntity();
                    if (null != emailRootChild) {
                        final String boundary = System.currentTimeMillis() + "-" + this.document.getDocumentId();
                        emailHeader = emailRootChild.createHeader("Content-Type");
                        emailHeader.setHeaderVal("multipart/alternative; boundary=\"" + boundary + "\"");

                        MIMEEntity emailChild = emailRootChild.createChildEntity();
                        if (null != emailChild) {
                            final String contentAsText = this.document.getRichTextItem(this.fieldName)
                                    .getContentAsText();
                            Stream stream = session.createStream();
                            stream.writeText(contentAsText);
                            emailChild.setContentFromText(stream, "text/plain; charset=\"UTF-8\"", MIMEEntity.ENC_NONE);
                            stream.close();

                            emailChild = emailRootChild.createChildEntity();
                            stream = session.createStream();
                            stream.writeText(this.getHTML());
                            emailChild.setContentFromText(stream, "text/html; charset=\"UTF-8\"", MIMEEntity.ENC_NONE);
                            stream.close();
                            stream.recycle();
                            stream = null;
                        }

                        // add embedded images....
                        final List<FileRowData> embeddedImages = this.getEmbeddedImagesList();
                        if (null != embeddedImages && !embeddedImages.isEmpty()) {
                            if (this.isDebugMode()) {
                                System.out.println("Adding Embedded Images...");
                            }
                            for (FileRowData embeddedImage : embeddedImages) {
                                emailRootChild = emailRoot.createChildEntity();
                                if (null != emailRootChild && embeddedImage instanceof AttachmentValueHolder) {
                                    InputStream is = null;
                                    try {
                                        String persistentName = ((AttachmentValueHolder) embeddedImage)
                                                .getPersistentName();
                                        String cid = ((AttachmentValueHolder) embeddedImage).getCID();
                                        emailHeader = emailRootChild.createHeader("Content-Disposition");
                                        emailHeader.setHeaderVal("inline; filename=\"" + persistentName + "\"");
                                        emailHeader = emailRootChild.createHeader("Content-ID");
                                        emailHeader.setHeaderVal("<" + cid + ">");
                                        is = this.getEmbeddedImageStream(persistentName);
                                        Stream stream = session.createStream();
                                        stream.setContents(is);
                                        emailRootChild.setContentFromBytes(stream, embeddedImage.getType(),
                                                MIMEEntity.ENC_IDENTITY_BINARY);
                                        if (this.isDebugMode()) {
                                            System.out.println("Added Embedded Image : " + persistentName);
                                        }
                                    } catch (IOException e) {
                                        if (this.isDebugMode()) {
                                            System.out.println("Adding Embedded Image failed : " + e.getMessage());
                                        }
                                        throw e;
                                    } finally {
                                        if (null != is) {
                                            is.close();
                                            is = null;
                                        }
                                    }
                                }
                            }
                            if (this.isDebugMode()) {
                                System.out.println("Completed Adding Embedded Images");
                            }
                        }

                        // add attachments....
                        final List<FileRowData> attachments = this.getDocument().getAttachmentList(this.getFieldName());
                        if (null != attachments && !attachments.isEmpty()) {
                            if (this.isDebugMode()) {
                                System.out.println("Adding Attachments...");
                            }
                            for (FileRowData attachment : attachments) {
                                emailRootChild = emailRoot.createChildEntity();
                                if (null != emailRootChild && attachment instanceof AttachmentValueHolder) {
                                    InputStream is = null;
                                    try {
                                        String persistentName = ((AttachmentValueHolder) attachment)
                                                .getPersistentName();
                                        String cid = ((AttachmentValueHolder) attachment).getCID();
                                        EmbeddedObject eo = this.getDocument().getDocument().getAttachment(
                                                persistentName);
                                        if (null != eo) {
                                            emailHeader = emailRootChild.createHeader("Content-Disposition");
                                            emailHeader.setHeaderVal("attachment; filename=\"" + persistentName + "\"");
                                            emailHeader = emailRootChild.createHeader("Content-ID");
                                            emailHeader.setHeaderVal("<" + cid + ">");
                                            is = eo.getInputStream();
                                            Stream stream = session.createStream();
                                            stream.setContents(is);
                                            emailRootChild.setContentFromBytes(stream, attachment.getType(),
                                                    MIMEEntity.ENC_IDENTITY_BINARY);
                                            if (this.isDebugMode()) {
                                                System.out.println("Added Attachment : " + persistentName);
                                            }
                                        }
                                    } catch (Exception e) {
                                        if (this.isDebugMode()) {
                                            System.out.println("Adding Attachment failed : " + e.getMessage());
                                        }
                                        throw e;
                                    } finally {
                                        if (null != is) {
                                            is.close();
                                            is = null;
                                        }
                                    }
                                }
                            }
                            if (this.isDebugMode()) {
                                System.out.println("Completed Adding Attachments");
                            }
                        }
                    }
                }
                emailDocument.send();
                session.setConvertMime(true);
                if (this.isDebugMode()) {
                    System.out.println("Completed send()");
                }
            } catch (NotesException e) {
                if (this.isDebugMode()) {
                    System.out.println("Failed send() with NotesException" + e.getMessage());
                }
                throw e;
            } catch (IOException e) {
                if (this.isDebugMode()) {
                    System.out.println("Failed send() with IOException" + e.getMessage());
                }
                throw e;
            } catch (Exception e) {
                if (this.isDebugMode()) {
                    System.out.println("Failed send() with Exception" + e.getMessage());
                }
                throw e;
            }
        }
    }

    // -------------------------------------------------------------------------

    public DominoDocument getDocument() {
        return this.document;
    }

    public void setDocument(final DominoDocument document) {
        this.document = document;
    }

    // -------------------------------------------------------------------------

    // -------------------------------------------------------------------------

    public String getFieldName() {
        return this.fieldName;
    }

    public void setFieldName(final String fieldName) {
        this.fieldName = fieldName;
    }

    // -------------------------------------------------------------------------

    public List<FileRowData> getEmbeddedImagesList() throws NotesException {
        if (null != document && null != fieldName) {
            return document.getEmbeddedImagesList(fieldName);
        }
        return null;
    }

    // -------------------------------------------------------------------------

    private InputStream getEmbeddedImageStream(final String fileName) throws NotesException, IOException {
        if (null != document && null != fieldName && null != fileName) {
            final DominoRichTextItem drti = document.getRichTextItem(fieldName);
            if (null != drti) {
                final PersistedContent pc = drti.getPersistedContent(FacesContext.getCurrentInstance(), fieldName,
                        fileName);
                if (null != pc) {
                    return pc.getInputStream();
                }
            }
        }
        return null;
    }

    // -------------------------------------------------------------------------

    public String getHTML() {
        StringBuffer html = new StringBuffer();
        html.append(getBannerHTML());
        html.append(getBodyHTML());
        html.append(getFooterHTML());
        return html.toString();
    }

    // -------------------------------------------------------------------------

    public String getBannerHTML() {
        return this.bannerHTML;
    }

    public void setBannerHTML(final String bannerHTML) {
        this.bannerHTML = bannerHTML;
    }

    // -------------------------------------------------------------------------

    public String getBodyHTML() {
        if (null != document && null != fieldName) {
            if (this.isDebugMode()) {
                System.out.println("Started getBodyHTML()");
            }
            final DominoRichTextItem drti = document.getRichTextItem(fieldName);
            if (null != drti) {
                try {
                    String html = drti.getHTML();
                    if (null != html) {
                        final List<FileRowData> fileRowDataList = document.getEmbeddedImagesList(fieldName);
                        if (null != fileRowDataList) {
                            final Matcher matcher = imgRegExp.matcher(html);
                            while (matcher.find()) {
                                String src = matcher.group();
                                final String srcToken = "src=\"";
                                final int x = src.indexOf(srcToken);
                                final int y = src.indexOf("\"", x + srcToken.length());
                                final String srcText = src.substring(x + srcToken.length(), y);
                                for (FileRowData fileRowData : fileRowDataList) {
                                    final String srcImage = fileRowData.getHref();
                                    final String cidImage = ((AttachmentValueHolder) fileRowData).getCID();
                                    if (srcText.endsWith(srcImage)) {
                                        final String newSrc = src.replace(srcText, "cid:" + cidImage);
                                        html = html.replace(src, newSrc);
                                        if (this.isDebugMode()) {
                                            System.out.println("CID referenced image: " + srcText + " with CID:"
                                                    + cidImage);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (this.isDebugMode()) {
                        System.out.println("Completed getBodyHTML() : " + html);
                    }
                    return html;
                } catch (Exception e) {
                    if (this.isDebugMode()) {
                        System.out.println("Failed getBodyHTML() : " + e.getMessage());
                    }
                }
            }
        }
        return null;
    }

    public void setBodyHTML(final String bodyHTML) throws NotImplementedException {
        if (this.isDebugMode()) {
            System.out.println("Method setBodyHTML(string) is not permitted");
        }
        throw new NotImplementedException();
    }

    // -------------------------------------------------------------------------

    public String getFooterHTML() {
        return this.footerHTML;
    }

    public void setFooterHTML(final String footerHTML) {
        this.footerHTML = footerHTML;
    }

    public String getUnid() {
        return unid;
    }

    public void setUnid(final String unid) {
        this.unid = unid;
    }

    // -------------------------------------------------------------------------

} // end EmailBean

Answer 1

Email.setUNID 的说法是错误的。尝试：

Email.setUnid(emlDoc.getUniversalID());

Xpages：使用后端文档通过 java 发送 html 电子邮件

Xpages: send html email via java using backend document

java

xpages

xpages-ssjs