的Lotus Notes插件进行拦截外发电子邮件（JAVA）

Question

我需要开发一个Lotus Notes插件，增加了一些UI到Lotus Notes主UI并执行当用户创建&下发送电子邮件：

1. 拦截传出的电子邮件，查看电子邮件中是否有附件。
2. 如果在电子邮件中找到任何附件，请取消发送电子邮件。
3. 操纵电子邮件的附件，然后（通过调用一些笔记API）

这是可行的Lotus Notes的插件再次发送邮件？

感谢&问候， 纳迪姆乌拉

Answer 1

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 

Answer 2

我认为你可以使用Java的荷花做笔记API。 从这里下载例子.. http://www.nsftools.com/tips/NotesTips.htm#javascraps 下载javascraps.zip file..it具有例如最大API ..

要完成UR工作u需要创建在Lotus Notes中的Java代理，然后你需要写Java代码根据您的要求使用Java API来完成任务。