/* ===================================================================
    * Copyright 2002-05 SRI International.
    * Released under the MOZILLA PUBLIC LICENSE Version 1.1
    * which can be obtained at http://www.mozilla.org/MPL/MPL-1.1.html
    * This software is distributed on an "AS IS"
    * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
    * See the License for the specific language governing rights and
    * limitations under the License.
    * =================================================================== */
  package com.sri.emo.controller;
  
  import java.io.StringReader;
  import java.sql.SQLException;
  import java.text.DateFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.TreeSet;
  
  import org.apache.log4j.Logger;
  import org.dom4j.Document;
  import org.dom4j.Element;
  
  import com.jcorporate.expresso.core.controller.Block;
  import com.jcorporate.expresso.core.controller.ControllerException;
  import com.jcorporate.expresso.core.controller.ExpressoRequest;
  import com.jcorporate.expresso.core.controller.ExpressoResponse;
  import com.jcorporate.expresso.core.controller.Input;
  import com.jcorporate.expresso.core.controller.NonHandleableException;
  import com.jcorporate.expresso.core.controller.Output;
  import com.jcorporate.expresso.core.controller.ServletControllerRequest;
  import com.jcorporate.expresso.core.controller.State;
  import com.jcorporate.expresso.core.controller.Transition;
  import com.jcorporate.expresso.core.dataobjects.jdbc.JoinedDataObject;
  import com.jcorporate.expresso.core.db.DBException;
  import com.jcorporate.expresso.core.dbobj.MultiDBObject;
  import com.jcorporate.expresso.core.misc.StringUtil;
  import com.jcorporate.expresso.core.registry.RequestRegistry;
  import com.jcorporate.expresso.core.security.ReadOnlyUser;
  import com.jcorporate.expresso.core.security.SuperUser;
  import com.jcorporate.expresso.core.security.filters.Filter;
  import com.jcorporate.expresso.core.security.filters.RawFilter;
  import com.jcorporate.expresso.services.dbobj.Setup;
  import com.sri.common.taglib.InputTag;
  import com.sri.emo.annotations.NodeTag;
  import com.sri.emo.annotations.NodeTagController;
  import com.sri.emo.annotations.PromptAddTag;
  import com.sri.emo.annotations.PromptDeleteTag;
  import com.sri.emo.dbobj.Attribute;
  import com.sri.emo.dbobj.IndentComparator;
  import com.sri.emo.dbobj.Node;
  import com.sri.emo.dbobj.NodeType;
  import com.sri.emo.dbobj.Part;
  import com.sri.emo.dbobj.PartsFactory;
  import com.sri.emo.dbobj.PickList;
  import com.sri.emo.dbobj.Relation;
  import com.sri.emo.dbobj.RelationType;
  
  /***
   * Handle Node manipulation.
   *
   * @author larry hamel
   */
  public class AddNodeAction extends NodeController {
      /***
  	 * 
  	 */
  	private static final long serialVersionUID = 1L;
  	// states
      public static final String VIEW_NODE = "viewNode";
      public static final String PROMPT_EXPORT_NODE = "promptExportNode";
      public static final String DO_EXPORT_NODE = "doExportNode";
      public static final String PROMPT_EDIT_NODE = "promptEditNode";
      public static final String DO_EDIT_NODE = "doEditNode";
      public static final String PROMPT_IMPORT_NODE = "promptImportNode";
      public static final String DO_IMPORT_NODE = "doImportNode";
      public static final String FINISH_IMPORT = "finishImportNode";
      public static final String INC_ATTRIB_ORDER = "incAttribOrder";
      public static final String DEC_ATTRIB_ORDER = "decAttribOrder";
      public static final String INC_REL_ORDER = "incRelOrder";
      public static final String DEC_REL_ORDER = "decRelOrder";
      public static final String EDIT_GROUP_DISPLAY = "EDIT_GROUP_DISPLAY";
      public static final String VIEW_PART = "viewPart";
  
      /***
       * limit number of chars that appear in display for a given field
       */
      public static final int MAX_CHARS_OUTPUT = 100;
  
      /***
       * checkbox name
       */
      public static final String PICK_LIST_ITEM = "PICK_LIST_ITEM";
      public static final String RETURN_TO = "RETURN_TO";
      public static final String PICKLISTS_TAGNAME = "PICKLISTS";
      public static final String IS_CHANGE_TITLE = "IS_CHANGE_TITLE";
     public static final String APPEND_TO_TITLE = "APPEND_TO_TITLE";
 
     private static Logger sLog = Logger.getLogger(AddNodeAction.class);
     public static final String DELETE_STRAY_ATTRIBUTES = "DEL_STRAY_ATTRIBS";
 
     public AddNodeAction() {
         addState(new State(VIEW_NODE, "View a node"));
 
         State promptState = new State(PROMPT_EDIT_NODE, "Edit Node");
         addState(promptState);
 
         State handleState = new State(DO_EDIT_NODE, "Submit Node");
         addState(handleState);
 
         addState(new State(PROMPT_IMPORT_NODE, "Prompt import node"));
         addState(new State(DO_IMPORT_NODE, "Do import node"));
         addState(new State(FINISH_IMPORT, "Finish import node"));
         addState(new State(PROMPT_EXPORT_NODE, "promptExportNode"));
         addState(new State(DO_EXPORT_NODE, "doExportNode"));
 
         addState(new State(INC_ATTRIB_ORDER, "incAttribOrder"));
         addState(new State(DEC_ATTRIB_ORDER, "decAttribOrder"));
 
         addState(new State(INC_REL_ORDER, "incRelOrder"));
         addState(new State(DEC_REL_ORDER, "decRelOrder"));
 
         State s = new State(VIEW_PART, "View Part");
         s.addRequiredParameter(Node.NODE_ID);
         s.addRequiredParameter(Part.PART_ID);
         addState(s);
 
         setInitialState(VIEW_NODE);
     }
 
     /***
      * Returns the title of this controller.
      *
      * @return String.
      */
     public String getTitle() {
         return "AddNodeAction Controller";
     }
 
     /***
      * Show view of node.  if user has rights, include edit buttons
      *
      * @param request  the <code>ExpressoRequest</code> object.
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException upon error.
      */
     protected void runViewNodeState(final ExpressoRequest request,
                                     final ExpressoResponse response) throws ControllerException {
         String nodeId = request.getParameter(Node.NODE_ID);
 
         if (nodeId == null) {
             throw new ControllerException("nodeId is a required parameter");
         }
 
         try {
             Node querynode = new Node(request, nodeId);
 
             if (!querynode.find()) {
                 response.addError("Cannot find an item with ID=" + nodeId +
                         ". You may have used an obsolete link, where the item"
                         + " has been deleted.  Please navigate to and use a "
                         + "fresh list of items.");
 
                 Transition trans = new Transition("", NodeAction.class,
                         NodeAction.INDEX);
                 if (isEmbeddedMode(request)) {
                     addEmbeddedParameter(trans);
                 }
                 trans.executeTransition(request, response);
 
                 return;
             }
 
             // for xml, short-circuit expresso path
             if (request.getParameter("isXML") != null) {
                 viewXML(querynode, request, response);
 
                 return;
             }
 
             querynode.view(this, request, response);
 
             return;
         } catch (Exception dbe) {
             throw new ControllerException(dbe);
         }
     }
 
     private void viewXML(final Node querynode, final ExpressoRequest request,
                          ExpressoResponse response) throws ControllerException {
         response.setCustomResponse(true);
 
         try {
             ModelXMLWriter writer = new ModelXMLWriter();
             Document document = writer.renderNodeAsXml(querynode, request);
             outputXML(document, request);
         } catch (Exception e) {
             throw new ControllerException(e);
         }
     }
 
     /***
      * Prompt for preferred xml format.
      *
      * @param request  the <code>ExpressoRequest</code> object.
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException upon error.
      */
     protected void runPromptExportNodeState(final ExpressoRequest request,
                                             final ExpressoResponse response) throws ControllerException {
         String nodeId = request.getParameter(Node.NODE_ID);
 
         if (nodeId == null) {
             throw new ControllerException("nodeId is a required parameter");
         }
 
         try {
             Node querynode = new Node(request, nodeId);
 
             if (!querynode.find()) {
                 response.addError("Cannot find an item with ID=" + nodeId +
                         ". You may have used an obsolete link, where the item "
                         + "has been deleted.  Please navigate to and use a " +
                         "fresh list of items.");
 
                 Transition trans = new Transition("", NodeAction.class, NodeAction.INDEX);
                 if (isEmbeddedMode(request)) {
                     addEmbeddedParameter(trans);
                 }
                 trans.executeTransition(request, response);
 
                 return;
             }
 
             Input in = new Input(IS_CHANGE_TITLE);
             in.setType(Input.ATTRIBUTE_CHECKBOX);
             in.setDefaultValue(IS_CHANGE_TITLE);
             response.add(in);
 
             in = new Input(APPEND_TO_TITLE);
             in.setType(Input.ATTRIBUTE_TEXTLINE);
             in.setDefaultValue(" copy");
             response.add(in);
 
             Block refsBlock = new Block(Node.REFS_ONLY);
             response.add(refsBlock);
 
             TreeSet set = PartsFactory.getEntities();
 
             for (Iterator iterator = set.iterator(); iterator.hasNext();) {
                 NodeType type = (NodeType) iterator.next();
                 in = new Input(type.getEntityName());
                 in.setType(Input.ATTRIBUTE_CHECKBOX);
                 in.setDefaultValue(type.getDisplayName());
 
                 if (type.isReferenceIdPreferred()) {
                     in.setAttribute(Input.SELECTED, "true");
                 }
 
                 refsBlock.add(in);
             }
 
             Transition trans = new Transition(DO_EXPORT_NODE, this);
             trans.setLabel("Export");
             trans.addParam(Node.NODE_ID, nodeId);
             if (isEmbeddedMode(request)) {
                 addEmbeddedParameter(trans);
             }
             response.add(trans);
         } catch (Exception dbe) {
             throw new ControllerException(dbe);
         }
     }
 
     /***
      * Prompt for preferred xml format.
      *
      * @param request  the <code>ExpressoRequest</code> object.
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException upon error.
      */
     protected void runDoExportNodeState(ExpressoRequest request,
                                         ExpressoResponse response) throws ControllerException {
         String nodeId = request.getParameter(Node.NODE_ID);
 
         if (nodeId == null) {
             throw new ControllerException("nodeId is a required parameter");
         }
 
         try {
             Node querynode = new Node(request, nodeId);
 
             if (!querynode.find()) {
                 response.addError("Cannot find an item with ID=" + nodeId
                         + ". You may have used an obsolete link, where the "
                         + "item has been deleted.  Please navigate to and use "
                         + "a fresh list of items.");
 
                 Transition trans = new Transition("", NodeAction.class, NodeAction.INDEX);
                 if (isEmbeddedMode(request)) {
                     addEmbeddedParameter(trans);
                 }
                 trans.executeTransition(request, response);
 
                 return;
             }
 
             viewXML(querynode, request, response);
 
             return;
         } catch (Exception dbe) {
             throw new ControllerException(dbe);
         }
     }
 
 
     /***
      * Views a given node.  In otherwords, creates the data and edit
      * links in a table format.
      *
      * @param querynode Node the node we're querying to form the data.
      * @param request   ExpressoRequest the ExpressoRequest object.
      * @param response  ExpressoResponse The ExpressoResponse object.
      * @throws DBException         upon error querying/operating on the node.
      * @throws ControllerException upon error populating the ExpressoResponse
      *                             object.
      */
     public void view(final Node querynode, final ExpressoRequest request,
                      final ExpressoResponse response) throws DBException, ControllerException {
         boolean canEdit = querynode.canRequesterWrite();
 
         String type = querynode.getNodeType();
         String titleStr = querynode.getNodeTitle();
 
         Output title = new Output(Node.NODE_TITLE, StringUtil.truncate(titleStr, MAX_CHARS_OUTPUT));
         response.add(title);
 
         response.add(new Output(Node.NODE_ID, querynode.getNodeId()));
 
         Output message = new Output(Node.NODE_ANNOTATION,
                 str(querynode.getNodeAnnotation()));
         response.add(message);
 
         Output comment = new Output(Node.NODE_COMMENT,
                 str(querynode.getNodeComment()));
         response.add(comment);
 
         // an edit link for the above node fields
         if (canEdit) {
             addEditLink(querynode.getNodeId(), response);
         }
 
         String nodeTypeTitle = request.getParameter(NodeType.DISPLAY_TITLE);
 
         if (nodeTypeTitle == null) {
             nodeTypeTitle = NodeType.getDisplayName(type);
         }
 
         response.add(new Output(NodeType.DISPLAY_TITLE, nodeTypeTitle));
 
         // parts, which are either attributes or (shared) node references
         //
         addParts(querynode, request, canEdit, response);
 
         if (querynode.canRequesterAdd()) {
             // add duplication link if user has ANY write ability
             addCloneLink(querynode.getNodeId(), response);
         }
 
         if (querynode.canRequesterWrite()) {
             addDeleteLink(querynode.getNodeId(), response);
         }
 
         // add list of items which contain me
         addContainedByLinks(querynode.getNodeId(), response);
         addViewXMLLink(querynode.getNodeId(), response);
         addTreeViewLink(querynode.getNodeId(), response);
 
         addTags(querynode, request, response);
     }
 
     /***
      * Grabs all node tags and drops them into a request attribute called 'NodeTags'
      * that the JSP can modify.
      *
      * @param queryNode Node the current node we're viewing.
      * @param request   ExpressoRequest the request
      * @param response  ExpressoResposne the response
      * @throws DBException         upon database error.
      * @throws ControllerException upon adding controller element error.
      */
     public static void addTags(final Node queryNode, final ExpressoRequest request, final ExpressoResponse response) throws DBException, ControllerException {
 
         Transition addTag = new Transition("addTag", "add tag", NodeTagController.class, PromptAddTag.NAME);
         addTag.addParam("nodeId", queryNode.getNodeId());
         response.add(addTag);
 
 
         Block tags = new Block("NodeTags");
 
 
         List allTags = queryNode.getTags();
 
         //List all nodes.
         DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT, request.getLocale());
 
         ReadOnlyUser requestingUser = request.getRequestingUser();
 
         for (Iterator i = allTags.iterator(); i.hasNext();) {
             NodeTag eachTag = (NodeTag) i.next();
             Block eachRow = new Block("Tag_" + eachTag.getTagId().toString());
             eachRow.add(new Output("dateAdded", df.format(eachTag.getAddedOn())));
             eachRow.add(new Output("tagValue", eachTag.getTagValue()));
             eachRow.add(new Output("addedBy", eachTag.getAddedBy()));
 
             boolean canDelete = RequestRegistry.getUser().isAdmin() ||
                     eachTag.getAddedBy().equals(requestingUser.getLoginName());
             if (canDelete) {
                 Transition edit = new Transition("[delete]",
                         NodeTagController.class, PromptDeleteTag.NAME);
                 edit.addParam(PromptDeleteTag.TAG_ID, eachTag.getTagId().toString());
                 eachRow.add(edit);
             }
             tags.add(eachRow);
         }
 
         response.add(tags);
 
     }
 
 
     private void addTreeViewLink(final String nodeId, final ExpressoResponse response) throws ControllerException {
         if (!isEmbeddedMode(response.getExpressoRequest())) {
             Transition trans = new Transition("", NodeAction.class, NodeAction.VIEW_TREE);
             trans.addParam(Node.NODE_ID, nodeId);
             response.add(trans);
         }
     }
 
     private void addParts(final Node node,
                           final ExpressoRequest request,
                           final boolean canEdit,
                           ExpressoResponse response) throws DBException, ControllerException {
 
         Part[] parts = PartsFactory.getParts(node.getNodeType());
         List allAttribs = node.getAttributes();
         List allRelations = node.getRawRelated();
         Block partList = new Block("allparts");
 
         // ignore the reflexive relations formed when src node is part of
         // another node
         // todo use the iAmAPartOf for appending a fake Part to end of tree, just like Flat view does
 //        List iAmAPartOf = filterIamPartOfMultiRelations(allRelations);
 
         for (int i = 0; (parts != null) && (i < parts.length); i++) {
             Part part = parts[i];
             ArrayList attribsForThisPart = new ArrayList();
             ArrayList relatedMultiesForThisPart = new ArrayList();
 
             if (part.isOwnedAttribute()) {
                 filterAttribs(allAttribs, part, attribsForThisPart);
             } else {
                 filterMultiRelations(allRelations, part, relatedMultiesForThisPart);
             }
 
             partList.add(getBlock(node,
                     request,
                     part,
                     canEdit,
                     attribsForThisPart,
                     relatedMultiesForThisPart));
 
             // remove the 'used' items from pool, to hasten next filtering, and provide 'cleanup' below
             allAttribs.removeAll(attribsForThisPart);
             allRelations.removeAll(relatedMultiesForThisPart);
         }
 
         // all relations and attribs should have been removed by now; any remaining are 'strays'
         deleteMultiRelations(allRelations, node);
         deleteAttributes(allAttribs, node);
 
         response.add(partList);
     }
 
     /***
      * remove relations of type "I am a part of" because these
      * are reflexive relations, not intended as true parts
      */
 //    private List filterIamPartOfMultiRelations(List allRelations) throws DBException {
 //        ArrayList iAmPartOf = new ArrayList();
 //        for (Iterator iterator = allRelations.iterator(); iterator.hasNext();) {
 //            MultiDBObject multiDBObject = (MultiDBObject) iterator.next();
 //            String relation = multiDBObject.getField(Node.RELATION_JOIN, Relation.RELATION_TYPE);
 //            if (RelationType.DEST_CONTAINS_SRC.equals(relation)) {
 //                iAmPartOf.add(multiDBObject);
 //            }
 //        }
 //
 //        allRelations.removeAll(iAmPartOf);
 //
 //        return iAmPartOf;
 //    }
 
     /***
      * remove relations of type "I am a part of" because these
      * are reflexive relations, not intended as true parts
      */
     public static List filterIamPartOfJoinedRelations(List allRelations) throws DBException {
         ArrayList iAmPartOf = new ArrayList();
         for (Iterator iterator = allRelations.iterator(); iterator.hasNext();) {
             JoinedDataObject oneJoinedRecord = (JoinedDataObject) iterator.next();
             String relation = oneJoinedRecord.getDataField("Relation." + Relation.RELATION_TYPE).asString();
             if (RelationType.DEST_CONTAINS_SRC.equals(relation)) {
                 iAmPartOf.add(oneJoinedRecord);
             }
         }
 
         allRelations.removeAll(iAmPartOf);
 
         return iAmPartOf;
     }
 
     private void filterMultiRelations(List allRelations, Part part, List relatedMultiesForThisPart) throws DBException {
         for (Iterator iterator = allRelations.iterator(); iterator.hasNext();) {
             MultiDBObject multiDBObject = (MultiDBObject) iterator.next();
             String nodetype = multiDBObject.getField(Node.NODE_JOIN, Node.NODE_TYPE);
             String relation = multiDBObject.getField(Node.RELATION_JOIN, Relation.RELATION_TYPE);
             if (part.getNodeRelation().equals(relation)
                     && part.getPartType().equals(nodetype)
                     ) {
                 relatedMultiesForThisPart.add(multiDBObject);
             }
         }
     }
 
     public static void filterJoinedDataObjectRelations(List allRelations,
                                                        Part part,
                                                        List relatedDataObjectsForThisPart) throws DBException {
         int relationsSize = allRelations.size();
         for (int i = 0; i < relationsSize; i++) {
             JoinedDataObject oneJoinedRecord = (JoinedDataObject) allRelations.get(i);
             String nodetype = oneJoinedRecord.getDataField("Node." + Node.NODE_TYPE).asString();
             String relation = oneJoinedRecord.getDataField("Relation." + Relation.RELATION_TYPE).asString();
             if (part.getNodeRelation().equals(relation)
                     && part.getPartType().equals(nodetype)
                     ) {
                 relatedDataObjectsForThisPart.add(oneJoinedRecord);
             }
         }
 
     }
 
 
     /***
      * iterate through list of all attributes and filter those that belong to the specified Part
      * into the output list
      *
      * @param allAttribs         input list of Attribute
      * @param part               membership criteria (the part type)
      * @param attribsForThisPart output list
      */
     public static void filterAttribs(List allAttribs, Part part, ArrayList attribsForThisPart) throws DBException {
         for (Iterator iterator = allAttribs.iterator(); iterator.hasNext();) {
             Attribute anAttrib = (Attribute) iterator.next();
             if (part.getPartType().equals(anAttrib.getAttribType())) {
                 attribsForThisPart.add(anAttrib);
             }
         }
     }
 
     /***
      * @param attribsLeftOver list of Attribute which should be deleted
      */
     public static void deleteAttributes(List attribsLeftOver, Node srcNode) throws DBException {
         for (Iterator iterator = attribsLeftOver.iterator(); iterator.hasNext();) {
             Attribute attrib = (Attribute) iterator.next();
             String msg = "Attribute type is not found in any part of parent node for attribute: "
                     + attrib.forKey() + " which has parentId/parent-title/type: "
                     + attrib.getParentNodeId() + "/" + srcNode.getNodeTitle() + "/" + attrib.getAttribType();
             if (StringUtil.toBoolean(Setup.getValueUnrequired(DELETE_STRAY_ATTRIBUTES))) {
                 sLog.warn(msg + " so it is being deleted.");
                 attrib.setRequestingUser(SuperUser.INSTANCE);
                 try {
                     attrib.delete();
                 } catch (DBException e) {
                     sLog.error("Cannot delete: ", e);
                 }
             } else {
                 sLog.warn(msg);
             }
         }
 
     }
 
     /***
      * @param relLeftOver list of MultiDBObjects which should have relation elements deleted
      */
     private void deleteMultiRelations(List relLeftOver, Node srcNode) throws DBException {
         // check on any leftover relations
         for (Iterator iterator = relLeftOver.iterator(); iterator.hasNext();) {
             MultiDBObject aMulti = (MultiDBObject) iterator.next();
             Relation rel = (Relation) aMulti.getDBObject(Node.RELATION_JOIN);
 
             // exception for relations that are reflexive--like the 'I am a part of' relation
             // that will write a reflexive relation from this object to its parent
             if (rel.isReflexive()) {
                 continue;
             }
 
             String msg = "Relation type is not found in any part of src node for relation: "
                     + rel.forKey()
                     + " for src node: " + srcNode.getNodeTitle() + "|" + srcNode.getNodeId();
             if (StringUtil.toBoolean(Setup.getValueUnrequired(DELETE_STRAY_ATTRIBUTES))) {
                 sLog.warn(msg + " so it is being deleted.");
                 rel.setRequestingUser(SuperUser.INSTANCE);
                 try {
                     rel.delete();
                 } catch (DBException e) {
                     sLog.error("Cannot delete: ", e);
                 }
             } else {
                 sLog.warn(msg);
             }
 
         }
     }
 
     /***
      * @param relLeftOver list of JoinedDataObject which should have relation elements deleted
      */
     public static void deleteJoinedRelations(List relLeftOver, Node srcNode) throws DBException {
         int relationsSize = relLeftOver.size();
         for (int i = 0; i < relationsSize; i++) {
             JoinedDataObject aJoin = (JoinedDataObject) relLeftOver.get(i);
             Relation rel = (Relation) aJoin.getNestedObject("Relation");
 
             String msg = "Relation type is not found in any part of src node for relation: "
                     + rel.forKey()
                     + " for src node: " + srcNode.getNodeTitle() + "|" + srcNode.getNodeId();
             if (StringUtil.toBoolean(Setup.getValueUnrequired(DELETE_STRAY_ATTRIBUTES))) {
                 sLog.warn(msg + " so it is being deleted.");
                 rel.setRequestingUser(SuperUser.INSTANCE);
                 try {
                     rel.delete();
                 } catch (DBException e) {
                     sLog.error("Cannot delete: ", e);
                 }
             } else {
                 sLog.warn(msg);
             }
         }
     }
 
     private void addViewXMLLink(final String nodeId, final ExpressoResponse response) throws ControllerException {
         Transition trans = new Transition(PROMPT_EXPORT_NODE, this);
         trans.addParam(Node.NODE_ID, nodeId);
         response.add(trans);
     }
 
     private void addContainedByLinks(final String nodeId,
                                      final ExpressoResponse response) throws DBException, ControllerException {
         Relation relation = new Relation(RequestRegistry.getUser());
         relation.setSrcId(nodeId);
         relation.setRelationTypeName(RelationType.DEST_CONTAINS_SRC);
 
         List containerRelations = relation.searchAndRetrieveList();
 
         if (containerRelations.size() > 0) {
             Block block = new Block(ROW_BLOCK);
             response.add(block);
 
             // first get container nodes
             ArrayList containers = new ArrayList(containerRelations.size());
 
             for (Iterator iterator = containerRelations.iterator();
                  iterator.hasNext();) {
                 Relation rel = (Relation) iterator.next(); 
                 containers.add(rel.getDestNode());
             }
 
             // sorts by title
             Collections.sort(containers);
 
             for (Iterator iter = containers.iterator(); iter.hasNext();) {
                 Node anode = (Node) iter.next();
                 Block row = new Block(ROW);
                 block.add(row);
 
                 Transition trans = new Transition(anode.getNodeTitle(),
                         getClass(), VIEW_NODE);
                 trans.addParam(Node.NODE_ID, anode.getNodeId());
                 row.add(trans);
                 row.setName(NodeType.getDisplayName(anode.getNodeType()));
                 row.add(new Output(Node.NODE_ID, anode.getNodeId()));
             }
         }
     }
 
     private void addDeleteLink(final String nodeId, final ExpressoResponse response) throws ControllerException {
         Transition deleteTransition = new Transition("Delete",
                 NodeAction.class, NodeAction.PROMPT_DELETE_NODE);
         deleteTransition.addParam(Node.NODE_ID, nodeId);
         response.add(deleteTransition);
     }
 
     /***
      * Adds the clone link.  Makes no sense in tree-view of a node.  Not
      * available in embedded mode.
      *
      * @param nodeId   String
      * @param response ExpressoResponse
      * @throws ControllerException
      */
     private void addCloneLink(final String nodeId, final ExpressoResponse response) throws ControllerException {
         if (!isEmbeddedMode(response.getExpressoRequest())) {
             Transition trans = new Transition("Duplicate", NodeAction.class,
                     NodeAction.PROMPT_CLONE_NODE);
             trans.addParam(Node.NODE_ID, nodeId);
             response.add(trans);
         }
     }
 
     /***
      * Adds the edit link for a paritcular node.
      *
      * @param nodeId   String
      * @param response ExpressoResponse
      * @throws ControllerException
      */
     private void addEditLink(final String nodeId, final ExpressoResponse response) throws ControllerException {
         Transition editTrans = new Transition("", getClass(),
                 PROMPT_EDIT_NODE);
         editTrans.addParam(Node.NODE_ID, nodeId);
         if (isEmbeddedMode(response.getExpressoRequest())) {
             addEmbeddedParameter(editTrans);
         }
         response.add(editTrans);
     }
     
     /***
      * prompt for NEW node or updates to node info--not attributes or shared relations,
      * but the few fields that the node owns: title, annotation, comment.
      * <p/>
      * can be for a new node, or existing
      *
      * @param request  the <code>ExpressoRequest</code> object.
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException upon error.
      */
     protected void runPromptEditNodeState(final ExpressoRequest request,
                                           final ExpressoResponse response) throws ControllerException {
         // type is required ONLY if this is request for new node
         // id is required ONLY if existing;
         // so one or the other is required
         String type = request.getParameter(Node.NODE_TYPE);
         String nodeId = request.getParameter(Node.NODE_ID);
 
         if ((type == null) && (nodeId == null)) {
             throw new ControllerException("either node ID or node type is requried.");
         }
 
         // target param added if this new item should be associated with existing object
         String targetRelation = request.getParameter(NodeAction.RELATION_TARGET);
         String relation = request.getParameter(Relation.RELATION_TYPE);
 
         if (targetRelation != null) {
             Input target = new Input(NodeAction.RELATION_TARGET);
             target.setType(InputTag.TYPE_HIDDEN);
             target.setDefaultValue(targetRelation);
             response.add(target);
 
             Input rel = new Input(Relation.RELATION_TYPE);
             rel.setType(InputTag.TYPE_HIDDEN);
             rel.setDefaultValue(relation);
             response.add(rel);
         }
 
         Transition errorTrans = NodeAction.getListTransition(null);
         if (isEmbeddedMode(request)) {
             addEmbeddedParameter(errorTrans);
         }
 
         // use existing info for fields if available
         String titleStr = "";
         String summaryStr = "";
         String commentStr = "";
         Node existing = null;
 
         boolean isExisting = nodeId != null;
 
         try {
             existing = new Node(request);
 
             if (isExisting) {
                 /***
                  * will throw if not found;
                  * programming error if provided nodeId is not found...
                  * hmm, what if someone deleted node in the meanwhile?
                  * still an edge case--we don't want to create a new one if user
                  * thinks that they are editing old one.
                  */
                 existing.setField(Node.NODE_ID, nodeId);
                 existing.retrieve();
                 type = existing.getNodeType();
 
                 Input hiddenId = new Input(Node.NODE_ID);
                 hiddenId.setType(InputTag.TYPE_HIDDEN);
                 hiddenId.setDefaultValue(nodeId);
                 response.add(hiddenId);
             } else {
                 // must specify the kind of node a priori for a new node
                 if (!NodeType.isValidType(type)) {
                     throw new ControllerException("invalid node type: " + type);
                 }
 
                 // get any params from request
                 if (!isValidAndPopulated(existing, new String[0], null,
                         request, response)) {
                     try {
                         errorTrans.addParam(Node.NODE_TYPE, type);
                         errorTrans.executeTransition(request, response);
                     } catch (Exception e) {
                         //getLogger().error(e);
                         throw new ControllerException(e);
                     }
                 }
             }
 
             titleStr = existing.getNodeTitle();
 
             // use raw field for default text value, since
             // it does not need translation to HTML
             Filter old = existing.setFilterClass(new RawFilter());
             summaryStr = existing.getNodeAnnotation();
             commentStr = existing.getNodeComment();
 
             // restore
             existing.setFilterClass(old);
 
             Input title = new Input(Node.NODE_TITLE);
             response.add(title);
             title.setMaxLength(255);
             title.setType(Input.ATTRIBUTE_TEXTLINE);
             title.setDefaultValue(titleStr);
             title.setDisplayLength(40);
 
             Input hiddenType = new Input(Node.NODE_TYPE);
             hiddenType.setType(InputTag.TYPE_HIDDEN);
             hiddenType.setDefaultValue(type);
             response.add(hiddenType);
 
             response.add(new Output(NodeType.DISPLAY_TITLE,
                     NodeType.getDisplayName(type)));
 
             Input message = getTextArea(Node.NODE_ANNOTATION, summaryStr);
             response.add(message);
 
             Input comment = getTextArea(Node.NODE_COMMENT, commentStr);
             response.add(comment);
 
             // Create an transition to submit the form
             Transition submitTransition = new Transition(DO_EDIT_NODE, this);
             if (isEmbeddedMode(request)) {
                 addEmbeddedParameter(submitTransition);
                 addReturnToSenderParameter(request, response, submitTransition);
             }
             submitTransition.setLabel("Save");
             response.add(submitTransition);
         } catch (DBException dbe) {
             response.addError("error: " + dbe.getMessage());
             getLogger().error("error: ", dbe);
             response.setFormCache();
 
             try {
                 errorTrans.executeTransition(request, response);
 
                 return;
             } catch (Exception e) {
                 throw new ControllerException(e);
             }
         }
     }
 
     /***
      * Write changes in attribute to DB.
      * note that an erased attribute means that we should *delete* the item from the DB
      *
      * @param request the <code>ExpressoRequest</code> object.
      * @param setNum  the set number.
      * @throws ControllerException upon error.
      */
     protected void saveAttribute(final ExpressoRequest request, final int setNum)
             throws ControllerException {
         try {
             String id = request.getParameter(getIdParamName(setNum)); // can be null/empty
             String value = request.getParameter(getValueParamName(setNum));
             String comment = request.getParameter(getCommentParamName(setNum));
 
             // String order = request.getParameter(getCommentParamName(setNum));
             // for case when attrib is new, these are required
             String nodeId = request.getParameter(Node.NODE_ID);
             String attribType = request.getParameter(Attribute.ATTRIBUTE_TYPE);
 
             boolean isNew = (id == null) || (id.length() == 0) ||
                     id.equals(Attribute.ATTRIBUTE_ID_UNKNOWN);
             Attribute attribute = new Attribute(RequestRegistry.getUser());
 
             if (!isNew) {
                 attribute.setDBName(request.getDataContext());
                 attribute.setField(Attribute.ATTRIBUTE_ID, id);
 
                 boolean found = attribute.find();
                 boolean isSame = found &&
                         value.equals(attribute.getAttribValue()) &&
                         comment.equals(attribute.getAttribComment());
                 boolean shouldDelete = found && !isSame &&
                         (value.length() == 0) && (comment.length() == 0);
 
                 if (isSame) {
                     // no saving necessary
                     return;
                 }
 
                 // edit is just to remove all text, signalling deletion
                 if (shouldDelete) {
                     attribute.delete();
 
                     return;
                 }
 
                 if (found) {
                     if (value != null) {
                         value = value.trim();
                     }
                     if (comment != null) {
                         comment = comment.trim();
                     }
                     attribute.setField(Attribute.ATTRIBUTE_VALUE, value);
                     attribute.setField(Attribute.ATTRIBUTE_COMMENT, comment);
                     attribute.update();
 
                     return;
                 }
             }
 
             // at this point, we know we have a new attribute
             // but do we really have something to save?
             if ((value.length() == 0) && (comment.length() == 0)) {
                 return; // nothing to save
             }
 
             // for new attribute, attribute type & nodeId are required
             if ((nodeId == null) || (nodeId.length() == 0) ||
                     (attribType == null) || (attribType.length() == 0)) {
                 throw new ControllerException("nodeId and attrib_type are required parameters");
             }
 
             // this node info should be in cache since we were just editing it
             Node node = new Node(request, nodeId);
 
             if (!node.find()) {
                 throw new ControllerException("cannot find node with id: " +
                         nodeId);
             }
 
             attribute.setAttributeType(attribType);
             attribute.setParentNodeId(nodeId);
             attribute.setParentNodeType(node.getNodeType());
 
             if (value != null) {
                 value = value.trim();
             }
             if (comment != null) {
                 comment = comment.trim();
             }
             attribute.setAttributeValue(value);
             attribute.setAttributeComment(comment);
             attribute.add();
         } catch (DBException dbe) {
             throw new ControllerException(dbe);
         }
     }
 
     protected Block getBlock(final Node node,
                              final ExpressoRequest request, final Part part,
                              boolean canEdit,
                              final List attribs, final List relatedNodes) throws DBException, ControllerException {
         Block block = null;
 
         if (part.isOwnedAttribute()) {
             block = getAttributeOutputBlock(node, request, part,
                     canEdit, attribs);
         } else {
             block = getSharedNodeBlock(node, request, part,
                     canEdit, relatedNodes);
         }
 
         // add help URL, common to both
         block.add(getHelpUrl(part.getPartType()));
 
         return block;
     }
 
     ;
 
     /***
      * Return an attributes of this node, of this type.
      *
      * @param parentNodeId the id of the parent in the tree.
      * @param request      the <code>ExpressoRequest</code> object.
      * @param attribType   the attribute type.
      * @return ArrayList of attributes
      * @throws ControllerException upon error.
      */
     protected ArrayList getAttributes(final String parentNodeId,
                                       final ExpressoRequest request,
                                       final String attribType)
             throws ControllerException {
         try {
             Attribute attribute = new Attribute(RequestRegistry.getUser());
             attribute.setDBName(request.getDataContext());
             attribute.setField(Attribute.NODE_ID, parentNodeId);
             attribute.setField(Attribute.ATTRIBUTE_TYPE, attribType);
 
             return attribute.searchAndRetrieveList(Attribute.ATTRIBUTE_ORDER);
         } catch (DBException e) {
             throw new ControllerException(e);
         }
     }
 
     /***
      * Utility to create an output block for a given attribute part.
      *
      * @param node    the parent node
      * @param request the <code>ExpressoRequest</code> object.
      * @param part    the <code>Part</code> to get the attributes from.
      * @param canEdit true if you want a transition link
      *                to the edit controller
      * @param attribs A list of attributes
      * @return Populated Block.
      * @throws DBException         upon database related error.
      * @throws ControllerException upon Expresso controller related error.
      */
     protected Block getAttributeOutputBlock(final Node node,
                                             final ExpressoRequest request, final Part part,
                                             boolean canEdit,
                                             final List attribs) throws DBException,
             ControllerException {
         if (!part.isOwnedAttribute()) {
             throw new DBException("cannot handle shared node here");
         }
 
         Block typeBlock = new Block("part" + part.getPartNum());
         typeBlock.add(new Output(Part.PART_DISPLAY_NAME, part.getPartLabel()));
 
         /***
          * add ATTRIBUTE_TYPE item to mark this block as an attribute
          */
         typeBlock.add(new Output(Attribute.ATTRIBUTE_TYPE, part.getPartType()));
         typeBlock.add(new Output(Part.PART_HELP_STRING, part.getPartType()));
 
 
         Attribute repAttrib = NodeAction.getRepAttribute(attribs, node, part.getPartType());
 
         if (repAttrib.hasCustomHandler()) {
             Transition trans = repAttrib.getViewTrans(request.getAllParameters());
             if (trans != null) {
                 Block rowBlock = new Block(ROW_BLOCK);
                 typeBlock.add(rowBlock);
                 rowBlock.add(trans);
                 rowBlock.add(repAttrib.getViewComment(request.getAllParameters()));
                 if (!repAttrib.getAttribCreated().equals(repAttrib.getAttribModified())) {
                     rowBlock.add(new Output(Attribute.ATTRIBUTE_MODIFIED, repAttrib.getAttribModified().substring(0, 10)));
                 }
             }
         } else {
             int numItems = 0;
             numItems = attribs.size();
 
             //
             // loop through all attributes found, creating block
             ///
             if (numItems > 0) {
                 int i = 0;
                 for (Iterator iterator = attribs.iterator(); iterator.hasNext();) {
                     Attribute attribute = (Attribute) iterator.next();
 
                     // only allow one item if singlevalued
                     if (part.isSingleValued() && i >= 1) {
                         break;
                     }
 
                     // Create a Block for each row tuple
                     Block rowBlock = new Block(ROW_BLOCK);
                     typeBlock.add(rowBlock);
 
                     try {
                         String value = attribute.getAttribValue();
 
                         if (part.hasPicklist()) {
                             // we must translate attribute value
                             //from id to display
                             value = attribute.getField(Attribute.ATTRIBUTE_PICKLIST_DISPLAY);
                         }
 
                         rowBlock.add(new Output(Attribute.ATTRIBUTE_VALUE,
                                 str(value)));
                         rowBlock.add(new Output(Attribute.ATTRIBUTE_COMMENT,
                                 str(attribute.getAttribComment())));
 
                         Transition trans = new Transition(NodeAction.
                                 PROMPT_EDIT_ATTRIB +
                                 attribute.getAttribId(), "", NodeAction.class,
                                 NodeAction.PROMPT_EDIT_ATTRIB);
                         trans.addParam(Attribute.ATTRIBUTE_ID,
                                 attribute.getAttribId());
                         rowBlock.add(trans);
                     } catch (DBException dbe) {
                         throw new ControllerException(dbe);
                     }
 
                     i++;
                 } // for
             }
         }
 
         if (canEdit) {
             Transition trans = part.getEditTrans(node.getNodeId(), request.getAllParameters());
             if (isEmbeddedMode(request)) {
                 addEmbeddedParameter(trans);
             }
 
             typeBlock.add(trans);
         }
 
         return typeBlock;
     }
 
     private Transition getHelpUrl(final String partType) {
         Transition trans = new Transition("", PartAction.class, PartAction.GENERATE_DOCS);
         trans.setAttribute("PART_HELP_STRING", partType);
         return trans;
     }
 
     /***
      * utility to create an input block for a given attribute part.
      * <p/>
      * this method is complicated by fact that we must associate sets of items
      * together as inputs;
      * we'll get back just a pile of parameters from the HTML page POST,
      * so we need a way to prefix param names such that
      * they can be grouped together later.
      *
      * @param nodeId      the id of the node.
      * @param srcNodeType source the node type.
      * @param request     The ExpressoRequest object
      * @param attribName  the name of the attribute to populate
      * @return a Block of Inputs for the attributes
      * @throws ControllerException upon any sort of error.
      */
     protected Block getAttributeInputBlock(final String nodeId,
                                            final String srcNodeType,
                                            final ExpressoRequest request,
                                            final String attribName) throws ControllerException {
         Block typeBlock = new Block("attributes");
         int itemNum = 0;
         ArrayList list = getAttributes(nodeId, request, attribName);
         Part part = null;
         boolean isMultiple = false;
 
         try {
             part = PartsFactory.getAttribPart(srcNodeType, attribName);
             isMultiple = part.areMultipleAttributesAllowed();
 
             if (part.hasPicklist()) {
                 Block rowBlock = new Block(ROW_BLOCK);
                 typeBlock.add(rowBlock);
 
                 String selected = "";
                 String comment = "";
 
                 if (list.size() > 0) {
                     // determine selected value, if any, as well as comment
                     Attribute attribute = (Attribute) list.get(0);
                     selected = attribute.getAttribValue();
 
                     if (selected == null) {
                         selected = "";
                     }
 
                     comment = attribute.getAttribComment();
 
                     if (comment == null) {
                         comment = "";
                     }
 
                     // add id for this existing attribute
                     Input hiddenId = new Input(getIdParamName(itemNum));
                     rowBlock.add(hiddenId);
                     hiddenId.setType(InputTag.TYPE_HIDDEN);
                     hiddenId.setDefaultValue(attribute.getAttribId());
                 }
 
                 // construct dropdown/picklist menu
                 addPicklistDropDown(nodeId, part, request, rowBlock, selected);
 
                 Input commentInput = getTextArea(getCommentParamName(itemNum),
                         comment,
                         part.numDisplayLines(),
                         TEXTAREA_NUM_COLS);
                 rowBlock.add(commentInput);
             } else {
                 // no picklist, use text fields for entry
                 //
                 // loop through all existing attributes with this
                 // name/parentNode,
                 // creating block for each
                 ///
                 for (Iterator iter = list.iterator(); iter.hasNext();) {
                     Attribute attribute = (Attribute) iter.next();
                     String attribId = attribute.getAttribId();
 
                     // Create a Block for each row tuple
                     Block rowBlock = new Block(ROW_BLOCK);
                     typeBlock.add(rowBlock);
 
                     Input valueInput = new Input(this
                             .getValueParamName(itemNum));
                     rowBlock.add(valueInput);
 
                     if (!part.hasPicklist()) {
                         valueInput.setMaxLength(4000);
                         valueInput.setType(InputTag.TYPE_TEXTAREA);
                         valueInput.setLines(part.numDisplayLines());
                         valueInput.setDisplayLength(TEXTAREA_NUM_COLS);
                         valueInput.setDefaultValue(attribute.getAttribValue());
                     }
 
                     Input commentInput = getTextArea(getCommentParamName(itemNum),
                             attribute.getAttribComment(),
                             part.numDisplayLines(),
                             TEXTAREA_NUM_COLS);
                     rowBlock.add(commentInput);
 
                     // add id for this existing attribute
                     Input hiddenId = new Input(getIdParamName(itemNum));
                     rowBlock.add(hiddenId);
                     hiddenId.setType(InputTag.TYPE_HIDDEN);
                     hiddenId.setDefaultValue(attribId);
 
                     itemNum++;
                 } // for
 
                 // Add spaces for new attributes.
                 // The new attributes are designated
                 // without an attribId, which distinguishes
                 // them from the existing IDs above
                 int num_empty_attribs = 5;
 
                 if (!isMultiple) {
                     if (itemNum == 0) {
                         num_empty_attribs = 1;
                     } else {
                         num_empty_attribs = 0;
                     }
                 }
 
                 for (int i = itemNum; i < (itemNum + num_empty_attribs); i++) {
                     // Create a Block for each row tuple
                     Block rowBlock = new Block(ROW_BLOCK);
                     typeBlock.add(rowBlock);
 
                     Input valueInput = getTextArea(getValueParamName(i),
                             null, part.numDisplayLines(),
                             TEXTAREA_NUM_COLS);
                     rowBlock.add(valueInput);
 
                     Input commentInput = getTextArea(getCommentParamName(i),
                             null, part.numDisplayLines(),
                             TEXTAREA_NUM_COLS);
                     rowBlock.add(commentInput);
                 } // for
             }
         } catch (Exception dbe) {
             throw new ControllerException(dbe);
         }
 
         return typeBlock;
     }
 
     /***
      * Utility to create an output block for a given shared node part.
      *
      * @param node         the source node
      * @param request      ExpressoRequest The <code>ExpressoRequest</code>
      *                     object
      * @param part         Part the part we're querying.
      * @param canEdit      boolean true if the user can edit the node
      * @param relatedNodes list of multidbobjects from node.getRawRelated() of related node info.
      * @return Block Bloc populated with the appropriate inputs/outputs, etc
      * @throws DBException         upon database access error
      * @throws ControllerException upon Controller related error.
      */
     protected Block getSharedNodeBlock(final Node node,
                                        final ExpressoRequest request, final Part part,
                                        final boolean canEdit,
                                        final List relatedNodes) throws DBException, ControllerException {
         if (part.isOwnedAttribute()) {
             throw new DBException("cannot handle attribute node here");
         }
         String relTarget = request.getParameter(NodeAction.RELATION_TARGET);
 
         Block typeBlock = new Block("part" + part.getPartNum());
         typeBlock.add(new Output(Part.PART_DISPLAY_NAME, part.getPartLabel()));
 
         // Relation.NODE_PART_RELATION_TYPE is signal to
         // JSP that this is shared block
         typeBlock.add(new Output(Relation.RELATION_TYPE, part.getNodeRelation()));
 
         // output for help string identifier (anchor name)
         // if type is same, output relation; if type is different, output part type
         if (node.getNodeType().equals(part.getPartType())) {
             typeBlock.add(new Output(Part.PART_HELP_STRING, part.getNodeRelation()));
         } else {
             typeBlock.add(new Output(Part.PART_HELP_STRING, part.getPartType()));
         }
 
         try {
 
             //
             // loop through all nodes found, creating block
             //
             for (Iterator iterator = relatedNodes.iterator(); iterator.hasNext();) {
                 MultiDBObject multiDBObject = (MultiDBObject) iterator.next();
                 Node relatedNode = (Node) multiDBObject.getDBObject(Node.NODE_JOIN);
 
                 // Create a Block for each row tuple
                 Block rowBlock = new Block(ROW_BLOCK);
                 typeBlock.add(rowBlock);
 
                 try {
                     //rowBlock.add(new Output(Node.NODE_TITLE, relatedNode.getNodeTitle()));
                     rowBlock.add(new Output(Node.NODE_ANNOTATION,
                             str(StringUtil.truncate(relatedNode.getNodeAnnotation(),
                                     MAX_CHARS_OUTPUT))));
                     rowBlock.add(new Output(Relation.RELATION_ANNOTATION,
                             str(StringUtil.truncate("", MAX_CHARS_OUTPUT))));
                     rowBlock.add(new Output(Node.NODE_COMMENT,
                             str(StringUtil.truncate(relatedNode.getNodeComment(),
                                     MAX_CHARS_OUTPUT))));
 
                     if (relatedNode.getNodeId().equals(relTarget)) {
                         rowBlock.add(new Output(NodeAction.RELATION_TARGET, "1"));
                     }
                     Transition trans = AddNodeAction.getViewTrans(relatedNode.
                             getNodeId());
                     trans.setLabel(relatedNode.getNodeTitle());
                     rowBlock.add(trans);
                 } catch (DBException dbe) {
                     throw new ControllerException(dbe);
                 }
             }
         } catch (DBException e) {
             throw new ControllerException(e);
         }
 
         if (canEdit) {
             Transition associateTrans = part.getEditTrans(node.getNodeId(), request.getAllParameters());
             associateTrans.setLabel("Edit");
             if (isEmbeddedMode(request)) {
                 addEmbeddedParameter(associateTrans);
             }
             typeBlock.add(associateTrans);
         }
 
         return typeBlock;
     }
 
     /***
      * Add number suffix from to Attribute.ATTRIBUTE_COMMENT_PREFIX.
      *
      * @param setNum The number suffix.
      * @return java.lang.String
      */
     private String getCommentParamName(final int setNum) {
         return Attribute.ATTRIBUTE_COMMENT_PREFIX + setNum;
     }
 
     /***
      * Add number suffix from to Attribute.ATTRIBUTE_ID_PREFIX.
      *
      * @param setNum the number suffix.
      * @return java.lang.String
      */
     private String getIdParamName(final int setNum) {
         return Attribute.ATTRIBUTE_ID_PREFIX + setNum;
     }
 
     /***
      * Add number suffix from to Attribute.ATTRIBUTE_VALUE_PREFIX.
      *
      * @param setNum the number suffix.
      * @return java.lang.String
      */
     private String getValueParamName(final int setNum) {
         return Attribute.ATTRIBUTE_VALUE_PREFIX + setNum;
     }
 
     private String getValueParamName(final String setNum) {
     	//Unused?
         return Attribute.ATTRIBUTE_VALUE_PREFIX + setNum;
     }
 
     /***
      * handle updates to node info--not attributes or shared relations,
      * but the few fields that the node owns: title, annotation, comment
      *
      * @param request  The ServletExpressoRequest object.
      * @param response The ExpressoResponse object.
      * @throws ControllerException upon error.
      */
     protected void runDoEditNodeState(final ExpressoRequest request,
                                       final ExpressoResponse response) throws ControllerException {
         try {
             /***
              * @todo auto-inc fields are not handled by isValidAndPopulated :-(
              */
             String nodeId = request.getParameter(Node.NODE_ID);
             boolean isExisting = nodeId != null;
             Node existing = null;
             String oldtitle = "";
 
             if (isExisting) {
                 existing = new Node(request, nodeId);
 
                 /***
                  * will throw if not found;
                  * programming error if provided nodeId is not found...
                  * hmm, what if someone deleted node in the meanwhile?
                  * still an edge case--we don't want to create a new one if user
                  * thinks that they are editing old one.
                  */
                 try {
                     existing.retrieve();
                     oldtitle = existing.getNodeTitleRaw();
                 } catch (DBException dbe) {
                     response.addError("error: " + dbe.getMessage());
                     getLogger().error("error: ", dbe);
                     response.setFormCache();
                     transition(PROMPT_EDIT_NODE, request, response);
 
                     return;
                 }
             }
 
             Node uploaded = new Node(RequestRegistry.getUser());
             String[] required = {Node.NODE_TYPE, Node.NODE_TITLE};
 
             if (!isValidAndPopulated(uploaded, required, PROMPT_EDIT_NODE,
                     request, response)) {
                 return; // method handles redirect back to failure state
                 //which will report errors
             }
 
             String title = uploaded.getNodeTitle();
 
             // handle case where NAME is already taken
             if (!(isExisting && title.equals(oldtitle))) {
                 // is new name already taken
                 Node checkName = new Node(RequestRegistry.getUser());
                 checkName.setNodeTitle(title);
 
                 if (checkName.find()) {
                     response.addError("Title is already in use; please choose another.");
                     response.setFormCache();
                     transition(PROMPT_EDIT_NODE, request, response);
 
                     return;
                 }
             }
 
             String targetId = request.getParameter(NodeAction.RELATION_TARGET);
             if (!isExisting) {
                 // save new node and we're finished
                 uploaded.setDBName(RequestRegistry.getDataContext());
                 uploaded.setNodeOwner(RequestRegistry.getUser().getLoginName());
 
                 try {
                     uploaded.add();
                     nodeId = uploaded.getNodeId();
 
                     // handle case where we are creating new node
                     // that should be related to some target automatically
                     if (targetId != null) {
                         Node target = new Node(targetId);
                         target.retrieve();
                         String relationType = request.getParameter(Relation.RELATION_TYPE);
 
                         Relation relation = new Relation(RequestRegistry.getUser());
                         relation.setField(Relation.RELATION_SRC, targetId);
                         relation.setField(Relation.RELATION_DEST, nodeId);
                         relation.setField(Relation.RELATION_TYPE, relationType);
                         relation.add();
                     }
                 } catch (DBException dbe) {
                     response.addError("error: " + dbe.getMessage());
                     getLogger().error("error: ", dbe);
                     response.setFormCache();
                     transition(PROMPT_EDIT_NODE, request, response);
 
                     return;
                 }
             } else {
                 // existing node
                 boolean isChanged = false; // we'll test this assumption below
 
                 String annotation = uploaded.getNodeAnnotation();
                 String comment = uploaded.getNodeComment();
 
                 // did we change the info in the node?
                 if (oldtitle.equals(title) &&
                         existing.getNodeAnnotation().equals(annotation) &&
                         existing.getNodeComment().equals(comment)) {
                     isChanged = false;
                 } else {
                     isChanged = true;
                     existing.setNodeTitle(title);
                     existing.setNodeAnnotation(annotation);
                     existing.setNodeComment(comment);
                     existing.setNodeOwner(RequestRegistry.getUser().getLoginName());
                 }
 
                 if (isChanged) { // only write to DB if there are changes
                     existing.update();
                 }
             } // existing node
 
             // if there is a return-to flag, go there
             if (targetId != null) {
 
                 // go back to target object if we were in 'creation dialog'
                 Transition trans = getViewTrans(targetId);
                 trans.addParam(NodeAction.RELATION_TARGET, nodeId); // add id of new item, for highlighting
                 if (this.redirectToSender((ServletControllerRequest) request, "Changes Saved")) {
                     return;
                 }
                 trans.redirectTransition(request, response);
             } else {
                 // now send off to display page
                 // do redirect to protect against refresh/resubmit
                 Transition trans = new Transition(VIEW_NODE, this);
                 trans.addParam(Node.NODE_ID, nodeId);
 
                 if (this.redirectToSender((ServletControllerRequest) request, "Changes Saved")) {
                     return;
                 }
 
                 trans.redirectTransition(request, response);
             }
         } catch (Exception dbe) {
             throw new ControllerException(dbe);
         }
     }
 
     private void addPicklistDropDown(final String parent_id, final Part part,
                                      final ExpressoRequest request, Block row, String selected) throws DBException {
         // construct dropdown/picklist menu
         Input valueInput = new Input(getValueParamName(parent_id));
         valueInput.setType(InputTag.TYPE_DROPDOWN);
         row.add(valueInput);
 
         String[][] picklistArray = null;
 
         try {
             picklistArray = part.getPicklistArray(request);
         } catch (Exception e) {
             throw new DBException(e);
         }
 
         boolean foundSelected = false;
 
         // if selected item not
         //found, and if better default not found
         String defaultSelected = picklistArray[0][0];
 
         for (int i = 0; i < picklistArray.length; i++) {
             valueInput.addValidValue(picklistArray[i][0], picklistArray[i][1]);
 
             if (selected.equals(picklistArray[i][0])) {
                 foundSelected = true;
                 valueInput.setDefaultValue(selected);
             }
 
             // if our standard default is in list, make it defaultSelected
             //(only used if selected not found)
             if (PickList.NOT_SPECIFIED_DISPLAY.equals(picklistArray[i][0])) {
                 defaultSelected = PickList.NOT_SPECIFIED_DISPLAY;
             }
         }
 
         // use default if there is no previous selection
         if (!foundSelected) {
             valueInput.setDefaultValue(defaultSelected);
         }
 
         // add edit link if user has rights
         List picklist = null;
 
         try {
             picklist = part.getPicklist(request);
         } catch (Exception e) {
             throw new DBException(e);
         }
 
         // need an initial entry in picklist to indicate who can
         // edit this list.
         if ((picklist.size() > 0) &&
                 ((PickList) picklist.get(0)).canRequesterWrite()) {
             Transition promptEditPicklist = new Transition(PicklistAction.PROMPT_LIST,
                     "", PicklistAction.class, PicklistAction.PROMPT_LIST);
             promptEditPicklist.addParam(PickList.NODE_TYPE, part.getParentType());
             promptEditPicklist.addParam(PickList.ATTRIBUTE_TYPE, part.getPartType());
             promptEditPicklist.addParam(Node.NODE_ID, parent_id);
             if (isEmbeddedMode(request)) {
                 addEmbeddedParameter(promptEditPicklist);
             }
             row.add(promptEditPicklist);
         }
     }
 
     /***
      * Prompt import of node from xml.
      *
      * @param request  The ExpressoRequest object.
      * @param response The ExpressoResponse object.
      * @throws ControllerException upon error.
      */
     protected void runPromptImportNodeState(final ExpressoRequest request,
                                             final ExpressoResponse response) throws ControllerException {
         try {
             Input in = getTextArea("xml", response.getFormCache("xml"), 20, 80);
             response.add(in);
 
             in = new Input(Node.RELATION_JOIN);
             in.setType(Input.ATTRIBUTE_CHECKBOX);
             in.addValidValue(Node.RELATION_JOIN,
                     "Ignore external relation IDs (relations not satisfied"
                             + " within XML itself are ignored)");
 
             String def = response.getFormCache(Node.RELATION_JOIN);
 
             if (def.length() == 0) {
                 def = Node.RELATION_JOIN;
             }
 
             in.setDefaultValue(def);
             in.setAttribute(Input.SELECTED, "true");
             response.add(in);
 
             Transition doImport = new Transition("Import", getClass(),
                     DO_IMPORT_NODE);
             response.add(doImport);
         } catch (Exception dbe) {
             throw new ControllerException(dbe);
         }
     }
 
     /***
      * Prompt import of node from xml.
      * assumes that all reference IDs ('ident') are for Nodes internal
      * to the given tree
      *
      * @param request  The ExpressoRequest object.
      * @param response The ExpressoResponse object.
      * @throws ControllerException upon error.
      */
     protected void runDoImportNodeState(final ExpressoRequest request, final ExpressoResponse response) throws
             ControllerException {
         try {
             String xml = request.getParameter("xml");
             Element root = PartAction.parseXML(new StringReader(xml));
             // ok, what to do with any external reference IDs?
             // optional parameter tells us what to do
             boolean isFindAllIds = StringUtil.toBoolean(request.getParameter(Node.RELATION_JOIN));
             boolean isExternalRefRequired =
                     request.getParameter(Node.RELATION_JOIN) != null;
             // whether we must look for IDs missing in xml tree externally
             // relations
             ModelXMLReader reader = new ModelXMLReader();
 
             Map allNodesByXML_ID = reader.parseImportXmlAndCreateNodes(isFindAllIds, isExternalRefRequired, root,
                     request, "//");
 
             // output list of imported items
             Block imports = new Block(ROW_BLOCK);
             Block delblock = new Block(ROW);
             response.add(imports);
             response.add(delblock);
 
             List allnodes = new ArrayList(allNodesByXML_ID.values());
             Collections.sort(allnodes, new IndentComparator());
 
             for (Iterator iterator = allnodes.iterator();
                  iterator.hasNext();) {
                 Node anode = (Node) iterator.next();
 
                 // put indent string as name of block
                 Block row = new Block(anode.getAttribute(Node.INDENT)
                         .toString());
                 imports.add(row);
 
                 Transition trans = getViewTrans(anode.getNodeId());
                 trans.setLabel(anode.getNodeTitle());
                 row.add(trans);
 
                 // row.add(NodeAction.getDeleteTrans(anode.getNodeId()));
                 row.add(new Output(Node.NODE_TYPE,
                         anode.getEntity().getDisplayName()));
 
                 // for feature to delete all todo: make this happen
                 delblock.add(new Output(NodeAction.DO_DELETE_NODE,
                         anode.getNodeId()));
             }
 
             // we would normally redirect, but we have long list of added nodes to show,
             // and re-import should hit node-title issues right away,
             //preventing mistaken double-imports
         } catch (SQLException e) {
             String msg = StringUtil.notNull(e.getMessage());
 
             if ((msg.indexOf("Violation of unique index") != -1) ||
                     (msg.indexOf("Duplicate entry") != -1)) {
                 msg = "Duplicate titles are not allowed: " + msg;
             }
 
             response.addError("error: " + msg);
             getLogger().error("error: ", e);
             response.setFormCache();
 
             Transition prompt = new Transition(PROMPT_IMPORT_NODE, this);
             if (isEmbeddedMode(request)) {
                 addEmbeddedParameter(prompt);
             }
 
             prompt.executeTransition(request, response);
         } catch (Exception e) {
             response.addError("error: " + e.getMessage());
             getLogger().error("error: ", e);
             response.setFormCache();
 
             Transition prompt = new Transition(PROMPT_IMPORT_NODE, this);
             if (isEmbeddedMode(request)) {
                 addEmbeddedParameter(prompt);
             }
 
             try {
                 prompt.executeTransition(request, response);
             } catch (NonHandleableException e1) {
                 throw new ControllerException(e1);
             }
         }
     }
 
 
     public static Transition getViewTrans(final String nodeId) {
         Transition trans = new Transition("", AddNodeAction.class,
                 AddNodeAction.VIEW_NODE);
         trans.addParam(Node.NODE_ID, nodeId);
 
         return trans;
     }
 
     /***
      * Increment order of this attribute
      *
      * @param request  The ExpressoRequest object.
      * @param response The ExpressoResponse object.
      * @throws ControllerException upon error.
      * @throws DBException         upon database related error.
      */
     protected void runIncAttribOrderState(final ExpressoRequest request,
                                           final ExpressoResponse response) throws DBException, ControllerException {
         Attribute attrib = getAttrib(request);
         renumAttribs(attrib, true);
         redirectToPromptEditAttrib(attrib, request, response);
     }
 
     private Attribute getAttrib(final ExpressoRequest request) throws DBException {
         Attribute attrib = new Attribute();
         attrib.setAttributeId(request.getParameter(Attribute.ATTRIBUTE_ID));
         attrib.retrieve();
 
         return attrib;
     }
 
     /***
      * increment order of this attribute
      *
      * @param request  The ExpressoRequest object.
      * @param response The ExpressoResponse object.
      * @throws ControllerException upon error.
      * @throws DBException         upon database related error.
      */
     protected void runDecAttribOrderState(final ExpressoRequest request, final ExpressoResponse response) throws
             DBException,
             ControllerException {
         Attribute attrib = getAttrib(request);
         renumAttribs(attrib, false);
         redirectToPromptEditAttrib(attrib, request, response);
     }
 
     private void redirectToPromptEditAttrib(final Attribute attrib,
                                             final ExpressoRequest request,
                                             final ExpressoResponse response) throws DBException,
             ControllerException {
         Node parent = attrib.getParentNode();
         Transition trans = new Transition("", NodeAction.class, NodeAction.PROMPT_EDIT_ATTRIB);
         if (isEmbeddedMode(request)) {
             addEmbeddedParameter(trans);
         }
         trans.addParam(Node.NODE_ID, parent.getNodeId());
         trans.addParam(Attribute.ATTRIBUTE_TYPE, attrib.getAttribType());
         trans.redirectTransition(request, response);
     }
 
     /***
      * The meat of the renumbering.
      *
      * @param attrib the attribute to reorder.
      * @param isInc  true if we are incrementing the attrib order.
      * @throws DBException upon database related error.
      */
     private void renumAttribs(final Attribute attrib, final boolean isInc) throws DBException {
         /***
          * @todo add test for going below 0 or above N, but for now,
          * depend on UI to not provide for those mistakes
          */
         Attribute[] attribs = attrib.getParentNode().getAttributes(attrib.
                 getAttribType());
         int oldnum = attrib.getOrderInt();
 
         if (isInc) {
             attrib.setOrder(oldnum + 1);
             attrib.updateOrder();
 
             // move upper neighbor down if nec.
             // index is 0-based, orderInt is 1-based
             int index = (oldnum + 1) - 1; // adjust to array index by -1
 
             if (attribs[index].getOrderInt() == (oldnum + 1)) {
                 attribs[index].setOrder(oldnum);
                 attribs[index].updateOrder();
             }
         } else {
             attrib.setOrder(oldnum - 1);
             attrib.updateOrder();
 
             // move lower neighbor up if nec.
             int index = oldnum - 1 - 1; // adjust to array index by -1
 
             if (attribs[index].getOrderInt() == (oldnum - 1)) {
                 attribs[index].setOrder(oldnum);
                 attribs[index].updateOrder();
             }
         }
     }
 
     /***
      * Increment order of this relation.
      *
      * @param request  The ExpressoRequest object.
      * @param response The ExpressoResponse object.
      * @throws ControllerException upon error.
      * @throws DBException         upon database related error.
      */
     protected void runIncRelOrderState(final ExpressoRequest request, final ExpressoResponse response) throws
             DBException,
             ControllerException {
         Relation rel = getRelation(request);
         renumRelations(rel, true);
         redirectToPicklist(rel, request, response);
     }
 
     private void redirectToPicklist(final Relation rel, final ExpressoRequest request,
                                     ExpressoResponse response) throws DBException, ControllerException {
         Node srcNode = rel.getSrcNode();
         Node destNode = rel.getDestNode();
         Transition trans = new Transition("", NodeAction.class, NodeAction.PROMPT_PICKLIST_NODE);
         if (isEmbeddedMode(request)) {
             addEmbeddedParameter(trans);
         }
         trans.addParam(Node.NODE_TYPE, destNode.getNodeType());
         trans.addParam(Node.NODE_ID, srcNode.getNodeId());
         trans.addParam(Relation.RELATION_TYPE, rel.getRelationTypeName());
         trans.redirectTransition(request, response);
     }
 
     private Relation getRelation(final ExpressoRequest request) throws DBException {
         Relation rel = new Relation(RequestRegistry.getUser());
         rel.setSrcId(request.getParameter(Relation.RELATION_SRC));
         rel.setDestId(request.getParameter(Relation.RELATION_DEST));
         rel.setRelationTypeName(request.getParameter(Relation.RELATION_TYPE));
         rel.retrieve();
 
         return rel;
     }
 
     /***
      * Dec order of this relation.
      *
      * @param request  The ExpressoRequest object.
      * @param response The ExpressoResponse object.
      * @throws ControllerException upon error.
      * @throws DBException         upon database related error.
      */
     protected void runDecRelOrderState(final ExpressoRequest request, final ExpressoResponse response) throws
             DBException,
             ControllerException {
         Relation rel = getRelation(request);
         renumRelations(rel, false);
         redirectToPicklist(rel, request, response);
     }
 
     /***
      * The mean of the renumbering.
      *
      * @param rel   The relation we're reordering
      * @param isInc true if we're incrementing the order.
      * @throws DBException upon database related error.
      */
     private void renumRelations(final Relation rel, final boolean isInc) throws DBException {
         // todo add test for going below 0 or above N, but for now,
         // depend on UI to not provide for those mistakes
         Node srcNode = rel.getSrcNode();
         Node destNode = rel.getDestNode();
         List multiList = srcNode.getRawRelated(rel.getRelationTypeName(),
                 destNode.getNodeType());
         ArrayList rellist = new ArrayList();
 
         for (Iterator iterator = multiList.iterator(); iterator.hasNext();) {
             MultiDBObject multi = (MultiDBObject) iterator.next();
             rellist.add(multi.getDBObject(Node.RELATION_JOIN));
         }
 
         Relation[] rels = (Relation[]) rellist.toArray(new Relation[rellist.size()]);
 
         int oldnum = rel.getOrderInt();
 
         if (isInc) {
             rel.setOrder(oldnum + 1);
             rel.updateOrder();
 
             // move upper neighbor down if nec.
             // index is 0-based, orderInt is 1-based
             int index = (oldnum + 1) - 1; // adjust to array index by -1
 
             if (rels[index].getOrderInt() == (oldnum + 1)) {
                 rels[index].setOrder(oldnum);
                 rels[index].updateOrder();
             }
         } else {
             rel.setOrder(oldnum - 1);
             rel.updateOrder();
 
             // move lower neighbor up if nec.
             int index = oldnum - 1 - 1; // adjust to array index by -1
 
             if (rels[index].getOrderInt() == (oldnum - 1)) {
                 rels[index].setOrder(oldnum);
                 rels[index].updateOrder();
             }
         }
     }
 
 
     /***
      * Views all attributes or relations of a given part.  Useful for when somebody
      * does not have permission to update an attribute, but the attribute
      * label is truncates (such as in treeview)
      *
      * @param request  ExpressoRequest the ExpressoRequest object.
      * @param response ExpressoResponse the ExpressoResponse object.
      * @throws ControllerException upon controller framework related error.
      * @throws DBException         upon database access related error.
      */
     protected void runViewPartState(final ExpressoRequest request,
                                     final ExpressoResponse response)
             throws ControllerException, DBException {
         Node node = NodeAction.getNode(request);
         Part part = new Part();
         part.setPartId(request.getParameter(Part.PART_ID));
         part.retrieve();
 
         request.getSession().setAttribute("ReadOnlyRequest", Boolean.TRUE);
 
         try {
             response.add(new Output(Attribute.ATTRIBUTE_DISPLAY_NAME, part.getPartLabel()));
 
             Transition viewTrans = AddNodeAction.getViewTrans(node.getNodeId());
             viewTrans.setLabel(node.getNodeTitle());
             response.add(viewTrans);
 
             // we reuse jsp code from entire 'flat' view of node, so we reuse the top
             // block of allparts, even though we will only be adding one part to it.
             Block allparts = new Block("allparts");
             response.add(allparts);
             if (part.isOwnedAttribute()) {
                 Attribute[] attribsArray = node.getAttributes(part.getPartType());
                 allparts.add(getAttributeOutputBlock(node, request, part, false, Arrays.asList(attribsArray)));
             } else {
                 List related = node.getRawRelated(part.getNodeRelation(), part.getPartType());
                 allparts.add(getSharedNodeBlock(node, request, part, false, related));
             }
 
         } catch (Exception e) {
             throw new ControllerException(e);
         }
 
     }
 
 }