用于拦截传出电子邮件的Lotus notes插件（JAVA）

我需要开发一个Lotus Notes插件，在Lotus Notes主UI中添加一些UI，并在用户创建和发送电子邮件时执行以下操作：

截取发送的电子邮件，查看电子邮件中是否有任何附件

如果在电子邮件中发现任何附件，请取消发送电子邮件

操纵电子邮件的附件，然后再次发送电子邮件（通过调用一些Notes API）

这在LotusNotes插件中可行吗

谢谢和问候，

---

Nadeem Ullah

我认为您可以使用java lotus notes API来实现。 从这里下载示例。。 下载javascraps.zip文件。它有最大API的示例

要完成您的工作，您需要在lotus notes中创建一个java代理，然后您需要根据需要使用java API编写java代码以完成任务。

package com.ibm.NotesJava.agents；
package com.ibm.NotesJava.agents;

import lotus.domino.*;

import java.io.File;
import java.io.FileInputStream;
import java.lang.*;
import java.util.*;
import java.awt.*;
import java.awt.List;
import java.awt.event.*;
import java.text.SimpleDateFormat;

public class MyJavaAgent extends AgentBase {
   //Main metho which is called by lotus notes
    public void NotesMain() {

        try {
            Session session = getSession();
            AgentContext agentContext = session.getAgentContext();

            // (Your code goes here)
            Name n = session.createName(agentContext.getEffectiveUserName());
            String st = n.getCommon();
            Log log=session.createLog("JAVA_AGENT");
            log.openFileLog("JAVA_AGENT.log");
            MessageBox mb = new MessageBox();
            try{
                log.logAction("");
                log.logAction("******************************Starting JAVA AGENT ************************");
                log.logAction("Hello " + st + "!"); 
                log.logAction("Executing JavaAgentTest with Agent: "+agentContext.getCurrentAgent().getName());
                Database db = agentContext.getCurrentDatabase();
                //System.out.println("Loading emaildetails.properties file from following location:C:\\Program Files\\Lotus\\Notes\\framework\\emaildetails.properties");
                log.logAction("Loading emaildetails.properties file from following location:C:\\Program Files\\Lotus\\Notes\\framework\\emaildetails.properties");
                Properties pro = new Properties();
                File fil = new File("C:\\Program Files\\Lotus\\Notes\\framework\\emaildetails.properties");
                //***********LOGIC*********
                DocumentCollection coll=agentContext.getUnprocessedDocuments();
                Document doc=coll.getFirstDocument();
                //get  input from user about the process area 
}
}

/************************Library Code ***********************************/
/* 
 * The MessageBox class allows you to create simple message boxes
 * using only the java.awt classes. All you have to do is create an instance
 * of a MessageBox and use it to call the doOkCancelDialog or the
 * doInputBox methods. You can use a single MessageBox instance to
 * create multiple dialogs.
 *
 * This class has been implemented here as an inner class, but there's
 * no reason why it couldn't be a class all by itself. The functionality to
 * create buttons and messageboxes has been modularized, so it should
 * be easy for you to add your own methods to this class, or make global
 * modifications as you desire.
 *
 * The only really complicated/weird thing I had to do was to write and
 * include the MultiLineLabel class, which is included towards the end
 * of this class as an inner class. Read the comments associated with
 * that class to see what's going on there.
 *
 * Make sure you import java.awt.* and java.awt.event.*
 *
 * Julian Robichaux -- http://www.nsftools.com
 */
class MessageBox {

    public final int NO_ACTION = -1;
    public final int CANCEL_ACTION = 0;
    public final int OK_ACTION = 1;
    int actionCode = NO_ACTION;

    Frame parent;
    Dialog msgbox;
    MultiLineLabel msglabel;        // our custom class, defined later
    Panel buttons;
    Button ok, cancel;
    TextField textbox;
    Choice dropdown;
    List multilist;

    public MessageBox ()  {
        // this is the invisible Frame we'll be using to call all of our Dialogs
        parent = new Frame();
    }

    public void dispose ()  {
        // use this when you're ready to clean up
        try { msgbox.dispose(); }  catch (Exception e)  {}
        try { parent.dispose(); }  catch (Exception e)  {}
    }

    /* 
     * This method will create a simple dialog box with a title, a message,
     * and Ok/Cancel buttons. It will halt execution of your program until
     * one of the buttons is clicked, and it will return either OK_ACTION
     * if the Ok button is clicked, or CANCEL_BUTTON if the Cancel
     * button is clicked.
     */
    public int doOkCancelDialog (String title, String message)  {
        actionCode = NO_ACTION;
        try  {
            // create the messagebox
            msgbox = new Dialog(parent, title, true);
            msgbox.setLayout(new BorderLayout());

            // create the label
            initMsglabel(message);
            msgbox.add("North", msglabel);

            // create the OK and Cancel buttons
            buttons = new Panel();
            buttons.setLayout(new FlowLayout());
            initOkButton();
            buttons.add(ok);
            initCancelButton();
            buttons.add(cancel);
            msgbox.add("South", buttons);

            // display everything (the system will wait until a button is pressed
            // before returning)
            displayMsgbox();
            msgbox.dispose();       // just in case the ActionListeners didn't fire...
        }  catch (Exception e)  {
        }

        return actionCode;
    }

    /* 
     * This method will create a dialog box that allows the user to enter
     * text into a field. It also has a title, a message, and Ok/Cancel buttons, 
     * and will halt execution of your program until one of the buttons is
     * clicked or the user enters text into the field and presses "Enter".
     * If the user clicks the Ok button or enters text and presses "Enter",
     * then the text in the field will be returned; otherwise, this method will
     * return null (which usually indicates that the user clicked Cancel).
     */
    public String doInputBox (String title, String message, String defaultText)  {
        actionCode = NO_ACTION;
        try  {
            // create the messagebox
            msgbox = new Dialog(parent, title, true);
            msgbox.setLayout(new BorderLayout());

            // create the label
            initMsglabel(message);
            msgbox.add("North", msglabel);

            // create the text field
            initTextbox(defaultText);
            msgbox.add("Center", textbox);

            // create the OK and Cancel buttons
            buttons = new Panel();
            buttons.setLayout(new FlowLayout());
            initOkButton();
            buttons.add(ok);
            initCancelButton();
            buttons.add(cancel);
            msgbox.add("South", buttons);

            // display everything (the system will wait until a button is pressed
            // before returning)
            displayMsgbox();
            msgbox.dispose();       // just in case the ActionListeners didn't fire...
        }  catch (Exception e)  {
        }

        if (actionCode == OK_ACTION)
            return textbox.getText();
        else
            return null;
    }

    /* 
     * This method will create a dialog box that allows the user to select from
     * a dropdown list. It also has a title, a message, and Ok/Cancel buttons, 
     * and will halt execution of your program until one of the buttons is
     * clicked. If the user clicks the Ok button then the text in the field will be 
     * returned; otherwise, this method will return null (which usually indicates 
     * that the user clicked Cancel).
     */
    public String doDropdownBox (String title, String message, String[] selections)  {
        actionCode = NO_ACTION;
        try  {
            // create the messagebox
            msgbox = new Dialog(parent, title, true);
            msgbox.setLayout(new BorderLayout());

            // create the label
            initMsglabel(message);
            msgbox.add("North", msglabel);

            // create the dropdown box
            initDropdown(selections);
            msgbox.add("Center", dropdown);

            // create the OK and Cancel buttons
            buttons = new Panel();
            buttons.setLayout(new FlowLayout());
            initOkButton();
            buttons.add(ok);
            initCancelButton();
            buttons.add(cancel);
            msgbox.add("South", buttons);

            // display everything (the system will wait until a button is pressed
            // before returning)
            displayMsgbox();
            msgbox.dispose();       // just in case the ActionListeners didn't fire...
        }  catch (Exception e)  {
        }

        if (actionCode == OK_ACTION)
            return dropdown.getSelectedItem();
        else
            return null;
    }

    /* 
     * This method will create a dialog box that allows the user to select from
     * a list of options (use the allowMultiSelect parameter to indicate whether
     * the user can select multiple items from the list [true] or just one [false]). 
     * It also has a title, a message, and Ok/Cancel buttons, and will halt 
     * execution of your program until one of the buttons is clicked. If the user 
     * clicks the Ok button then the text in the field will be returned; otherwise, 
     * this method will return null (which usually indicates that the user clicked 
     * Cancel or didn't select anything).
     */
    public String[] doMultilistBox (String title, String message, String[] selections, boolean allowMultiSelect)  {
        actionCode = NO_ACTION;
        try  {
            // create the messagebox
            msgbox = new Dialog(parent, title, true);
            msgbox.setLayout(new BorderLayout());

            // create the label
            initMsglabel(message);
            msgbox.add("North", msglabel);

            // create the multilist field
            initMultilist(4, allowMultiSelect, selections);
            msgbox.add("Center", multilist);

            // create the OK and Cancel buttons
            buttons = new Panel();
            buttons.setLayout(new FlowLayout());
            initOkButton();
            buttons.add(ok);
            initCancelButton();
            buttons.add(cancel);
            msgbox.add("South", buttons);

            // display everything (the system will wait until a button is pressed
            // before returning)
            displayMsgbox();
            msgbox.dispose();       // just in case the ActionListeners didn't fire...
        }  catch (Exception e)  {
        }

        if ((actionCode == OK_ACTION) && 
            (java.lang.reflect.Array.getLength(multilist.getSelectedItems()) > 0))
            return multilist.getSelectedItems();
        else
            return null;
    }

    /*
     * The private methods below are simply reusable modular functions for
     * creating various elements that may appear in a MessageBox dialog.
     * They make it easier to write new public methods that create different
     * kinds of dialogs, and also allow you to make global changes to all your
     * dialog components pretty easily.
     */
     private void initMsglabel (String message)  {
        // the actual message in the MessageBox (using the custom
        // MultiLineLabel class, included below)
        msglabel = new MultiLineLabel(message);
     }

    private void initOkButton ()  {
        // the OK button
        ok = new Button("OK");
        ok.addActionListener( new ActionListener()  {
            public void actionPerformed(ActionEvent e)  {
                actionCode = OK_ACTION;
                msgbox.dispose();
            }
        } );
    }

    private void initCancelButton ()  {
        // the Cancel button
        cancel = new Button("Cancel");
        cancel.addActionListener( new ActionListener()  {
            public void actionPerformed(ActionEvent e)  {
                actionCode = CANCEL_ACTION;
                msgbox.dispose();
            }
        } );
    }

    private void initTextbox (String defaultText)  {
        // the field that allows a user to enter text in an InputBox
        textbox = new TextField(defaultText, 40);
        // the ActionListener here will get called if the user presses "Enter"
        textbox.addActionListener( new ActionListener()  {
            public void actionPerformed(ActionEvent e)  {
                actionCode = OK_ACTION;
                msgbox.dispose();
            }
        } );
    }

    private void initDropdown (String[] selections)  {
        // a dropdown box that allows a user to select from a list of
        // multiple items
        dropdown = new Choice();
        for (int i = 0; i < java.lang.reflect.Array.getLength(selections); i++)
            dropdown.add(selections[i]);
    }

    private void initMultilist (int numOfLines, boolean allowMultiSelect, String[] selections)  {
        // a multiple selection box that allows a user to select one or 
        // more items. numOfLines indicates how many lines should be
        // visible at a time, allowMultiSelect is a boolean value indicating 
        // whether or not the user should be allowed to select more than
        // one item from the list, and selections is an array of Strings that 
        // is used to populate the selection box
        multilist = new List(numOfLines, allowMultiSelect);
        for (int i = 0; i < java.lang.reflect.Array.getLength(selections); i++)
            multilist.add(selections[i]);
    }

    private void displayMsgbox ()  {
        // once all of the components have been added to a dialog,
        // use this method to display it
        Dimension d = msgbox.getToolkit().getScreenSize();
        msgbox.setLocation(d.width/3, d.height/3);      // center the dialog (sort of)
        msgbox.pack();                      // organize all its components
        msgbox.setResizable(false);     // make sure the user can't resize it
        msgbox.toFront();                   // give it focus
        msgbox.setVisible(true);                // and display it
    }

    /*
     * Okay, this is a pain, but java.awt doesn't natively have a Label-type class
     * that allows you to display text that's more than one line. So I had to write one
     * myself. The class below is a modification of some code from the fantastic
     * book, "Java in a Nutshell".
     *
     * The big change I made was to allow this multi-line label to have a fixed width,
     * so the Label wouldn't fly off the screen if you had a big paragraph of text to
     * display. The width is specified in "columns", which I defined as the width of
     * the letter "X" in whatever font is being used. The text that you add to the label
     * is automatically split into chunks that are no longer than the number of columns
     * specified (you'll see the code to do this in the parseLabel method).
     *
     * This sample implementation is an inner class of the MessageBox class, although
     * it could also be a separate class all by itself. I made it an inner class to make it
     * easier to copy and paste everything from one agent to another.
     *
     * Julian Robichaux -- http://www.nsftools.com
     */
    class MultiLineLabel extends Canvas  {
        // a custom class that will display a text label at a fixed width across
        // multiple lines
        // (modification of MultiLineLabel class from "Java in a Nutshell")
        String label;
        String[] lines;
        int rows = 1;
        int cols = 40;
        int margin = 6;
        int rowHeight;
        int lineAscent;
        int maxWidth;

        public MultiLineLabel (String text)  {
            // create a label with the default width
            label = text;
        }

        public MultiLineLabel (String text, int columns)  {
            // create a label with the specified number of "columns" (where a column
            // is the width of "X" in the font that we're using)
            if (columns > 0)
                cols = columns;
            label = text;
        }

        protected void measure ()  {
            // get the global values we use in relation to our current font
            FontMetrics fm = this.getFontMetrics(this.getFont());
            if (fm == null)
                return;

            rowHeight = fm.getHeight();
            lineAscent = fm.getAscent();
            maxWidth = fm.stringWidth("X") * cols;
        }

        private int stringWidth (String text)  {
            // calculate the width of a String using our current font
            FontMetrics fm = this.getFontMetrics(this.getFont());
            if (fm == null)
                return 0;
            return fm.stringWidth(text);
        }

        public Font getFont ()  {
            // return the font that we're currently using
            return super.getFont();
        }

        public void setFont (Font f)  {
            // change the font that we're currently using, and redraw the
            // label with the new font
            super.setFont(f);
            repaint();
        }

        public void addNotify ()  {
            // automatically invoked after our label/Canvas is created but 
            // before it's displayed (FontMetrics aren't available until
            // super.addNotify() has been called)
            super.addNotify();
            measure();
        }

        public Dimension getPreferredSize ()  {
            // called by the LayoutManager to find out how big we want to be
            if (lines == null)
                setText(label);
            return new Dimension(maxWidth + (2 * margin), (rows * rowHeight) + (2 * margin));
        }

        public Dimension getMinimumSize ()  {
            // called by the LayoutManager to find out what our bare minimum
            // size requirements are
            if (lines == null)
                setText(label);
            return new Dimension(maxWidth, (rows * rowHeight));
        }

        public void setText (String text)  {
            // change the text we're using for this label
            label = text;
            parseLabel();
        }

        private void parseLabel ()  {
            // parses the text we want to display in the label, so that the lines[]
            // variable contains lines of text that are no wider than maxWidth
            String token, word;
            StringBuffer msg = new StringBuffer("");
            StringBuffer line = new StringBuffer("");

            // do an initial measurement, to make sure we have maxWidth
            measure();
            rows = 0;

            // we'll be tokenizing the label String twice, first at every end-of-line
            // character ('\n') and then at every space (if the lines are too long), 
            // in order to generate an StringBuffer of proper length lines, all 
            // separated by \n
            java.util.StringTokenizer st1 = new java.util.StringTokenizer(label, "\n", false);
            while (st1.hasMoreTokens())  {
                token = st1.nextToken();
                if (stringWidth(token) <= maxWidth)  {
                    // if the whole line is shorter than the maxWidth allowed, we can
                    // just add this line to the buffer and get the next one
                    rows++;
                    msg.append(token + "\n");
                }  else  {
                    // if the line was too long, we'll have to break it up manually by
                    // tokenizing the line at every space and adding words together
                    // one by one until we have a line that's greater than maxWidth;
                    // then we can add that shorter line to the buffer and keep doing
                    // that until we're out of words
                    java.util.StringTokenizer st2 = new java.util.StringTokenizer(token, " ", false);
                    while (st2.hasMoreTokens())  {
                        word = st2.nextToken();
                        if ((stringWidth(line.toString()) + stringWidth(word)) > maxWidth)  {
                            rows++;
                            msg.append(line.toString() + "\n");
                            line.setLength(0);
                            line.append(word + " ");
                        }  else  {
                            line.append(word + " ");
                        }
                    }
                    // after we've run out of words, add any remaining text to the buffer, too
                    if (line.length() > 0)  {
                            rows++;
                            msg.append(line.toString() + "\n");
                    }
                }
            }

            // once we're done, split the buffer into the lines[] array
            java.util.StringTokenizer st = new java.util.StringTokenizer(msg.toString(), "\n");
            lines = new String[rows];
            for (int i = 0; i < rows; i++)
                lines[i] = st.nextToken();

        }

        public void paint (Graphics g)  {
            // draw the actual label to the screen, with space around the edges
            // based on the margins we've specified (for some reason, we have to
            // call setLabel instead of just parseText here in order to get the size
            // right, which is a little redundant, but whatever works...)
            int y;
            setText(label);
            Dimension d = this.getSize();
            y = lineAscent + (d.height - (rows * rowHeight)) / 2;
            for (int i = 0; i < rows; i++, y += rowHeight)
                g.drawString(lines[i], margin, y);
        }

    }
}// end of the MultiLineLabel class

导入lotus.domino.*；
导入java.io.File；
导入java.io.FileInputStream；
导入java.lang.*；
导入java.util.*；
导入java.awt.*；
导入java.awt.List；
导入java.awt.event.*；
导入java.text.simpleDataFormat；
公共类MyJavaAgent扩展了AgentBase{
//lotusnotes调用的Main方法
公共无效注释main（）{
试一试{
Session=getSession（）；
AgentContext AgentContext=session.getAgentContext（）；
//（您的代码在这里）
Name n=session.createName（agentContext.getEffectiveUserName（））；
字符串st=n.getCommon（）；
Log Log=session.createLog（“JAVA_代理”）；
openFileLog（“JAVA_AGENT.log”）；
MessageBox mb=新建MessageBox（）；
试一试{
log.logAction（“”）；
log.logAction（“**********************************启动JAVA代理*******************************”）；
logAction（“Hello”+st+“！”）；
logAction（“使用代理执行JavaAgentSet:+agentContext.getCurrentAgent（）.getName（））；
数据库db=agentContext.getCurrentDatabase（）；
//System.out.println（“从以下位置加载emaildetails.properties文件：C:\\Program Files\\Lotus\\Notes\\framework\\emaildetails.properties”）；
log.logAction（“从以下位置加载emaildetails.properties文件：C:\\Program Files\\Lotus\\Notes\\framework\\emaildetails.properties”）；
Properties pro=新属性（）；
File fil=新文件（“C:\\Program Files\\Lotus\\Notes\\framework\\emaildetails.properties”）；
//***********逻辑*********
DocumentCollection coll=agentContext.getUnprocessedDocuments（）；
Document doc=coll.getFirstDocument（）；
//从用户处获取有关流程区域的输入
}
}
/************************库代码***********************************/
/* 
*MessageBox类允许您创建简单的消息框
*只使用java.awt类。您所要做的就是创建一个实例
*并使用它调用doOkCancelDialog或
*doInputBox方法。您可以使用单个MessageBox实例
*创建多个对话框。
*
*这个类在这里被实现为一个内部类，但是
*没有理由说它不能单独成为一个类
*创建按钮和消息框已经模块化，因此应该
*您可以轻松地将自己的方法添加到此类中，或使其成为全局方法
*根据您的需要进行修改。
*
*我要做的唯一一件真正复杂/奇怪的事就是写和写
*包括MultiLineLabel类，该类包含在末尾
*将此类作为内部类的引用。请阅读与
*那堂课是为了看看那里发生了什么。
*
*确保导入java.awt.*和java.awt.event*
*
*朱利安·罗比丘--http://www.nsftools.com
*/
类消息框{
公共最终int NO_ACTION=-1；
公共最终int取消动作=0；
公共最终int OK_ACTION=1；
int actionCode=无动作；
帧父；
对话框msgbox；
MultiLineLabel msglabel；//我们的自定义类，稍后定义
面板按钮；
按钮确定，取消；
文本字段文本框；
选择下拉列表；
列表多列表；
公共消息框（）{
//这是我们用来调用所有对话框的不可见框架
父项=新帧（）；
}
公共空间处置（）{
//当你准备清理的时候用这个
请尝试{msgbox.dispose（）；}捕获（异常e）{}
请尝试{parent.dispose（）；}捕获（异常e）{}
}
/* 
*此方法将创建一个带有标题、消息、，
*和“确定/取消”按钮。它将停止程序的执行，直到
*单击其中一个按钮，它将返回OK_动作
*如果单击“确定”按钮，或如果单击“取消”按钮，则单击“取消”
*按钮被点击。
*/
public int doOkCancelDialog（字符串标题、字符串消息）{
动作代码=无动作；
试一试{
//创建messagebox
msgbox=新建对话框（父级、标题、true）；
setLayout（新的BorderLayout（））；
//创建标签
initMsglabel（消息）；
msgbox.add（“北”，msglabel）；
//创建“确定”和“取消”按钮
按钮=新面板（）；
按钮.setLayout（新的FlowLayout（））；
initOkButton（）；
按钮。添加（确定）；
initCancelButton（）；
按钮。添加（取消）；
添加（“南”，按钮）；
//显示所有内容（系统将等待按钮按下
//返回前）
displayMsgbox（）；
msgbox.dispose（）；//以防ActionListeners没有启动。。。
}捕获（例外e）{
}
返回操作码；
}
/* 
*此方法将创建一个对话框，允许用户