Metacat

/*

 * ClientViewHelper.java

 *

 * Created on June 25, 2007, 9:57 AM

 *

 * To change this template, choose Tools | Template Manager

 * and open the template in the editor.

 */

package edu.ucsb.nceas.metacat.clientview;

import com.oreilly.servlet.multipart.FilePart;

import com.oreilly.servlet.multipart.MultipartParser;

import com.oreilly.servlet.multipart.ParamPart;

import com.oreilly.servlet.multipart.Part;

import edu.ucsb.nceas.metacat.MetaCatUtil;

import edu.ucsb.nceas.metacat.client.MetacatClient;

import edu.ucsb.nceas.metacat.client.MetacatFactory;

import edu.ucsb.nceas.metacat.client.MetacatInaccessibleException;

import edu.ucsb.nceas.utilities.XMLUtilities;

import java.io.BufferedReader;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.io.StringReader;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Properties;

import java.util.TreeMap;

import java.util.Vector;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import javax.xml.xpath.XPath;

import javax.xml.xpath.XPathConstants;

import javax.xml.xpath.XPathExpressionException;

import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

/**

 *

 * @author barteau

 */

public class ClientViewHelper {

    private XPath                                       xpath = XPathFactory.newInstance().newXPath();

    private HttpSession                                 clientSession;

    private ClientView                                  clientViewBean = null;

    private MetacatClient                               metacatClient = null;

    private boolean                                     loggedIn = false;

    private Document                                    metadataDoc = null;

    private int                                         sizeLimit;

    private String                                      contactName = "";

    private static final String                         LDAP_TEMPLATE = "uid=%1s,o=%2s,dc=ecoinformatics,dc=org";

    public static final String                          DOWNLOAD_ACTION = "Download";

    /**

     * Creates a new instance of ClientViewHelper

     */

    public ClientViewHelper(HttpServletRequest request) throws MetacatInaccessibleException {

        String                              metacatPath = "http://%1s%2s/metacat";

        String                              host, context, button, tmp;

        clientSession = request.getSession();

        host = request.getHeader("host");

        context = request.getContextPath();

        //metacatPath = String.format(metacatPath, host, context);

        tmp = metacatPath.replaceFirst("%1s", host);

        metacatPath = tmp.replaceFirst("%2s", context);

        metacatClient = (MetacatClient) MetacatFactory.createMetacatConnection(metacatPath);

        sizeLimit = (new Integer(MetaCatUtil.getOption("datafilesizelimit"))).intValue();

    }

    public String clientRequest(HttpServletRequest request, HttpServletResponse response)  {

        String                              result = null, action, message, serverResponse;

        String                              button, contentType, posted_ldapUserName, tmp;

        MultipartParser                     multipartParser;

        int                                 fileIdx;

        if (clientViewBean == null)

            clientViewBean = (ClientView) clientSession.getAttribute(ClientView.CLIENT_VIEW_BEAN);

        if (clientViewBean != null) {

            action = clientViewBean.getAction();

            contentType = request.getContentType();

            //*** BEGIN: manual bind params to bean (if we arrived here via the ClientViewHelper.jspx).

            if (action == null || action.equals("")) {

                if (contentType != null && contentType.contains("multipart/form-data")) {

                    action = "Upload";

                } else {

                    action = request.getParameter("action");

                    clientViewBean.setAction(action);

                    clientViewBean.setDocId(request.getParameter("docid"));

                    clientViewBean.setMetaFileDocId(request.getParameter("metadataDocId"));

                    clientViewBean.setQformat(request.getParameter("qformat"));

                }

            }

            //*** END: manual bind params to bean.

            if (action != null) {

                try {

                    if (action.equals("Login")) {

                        //posted_ldapUserName = String.format(LDAP_TEMPLATE, clientViewBean.getUsername(), clientViewBean.getOrganization());

                        tmp = LDAP_TEMPLATE.replaceFirst("%1s", clientViewBean.getUsername());

                        posted_ldapUserName = tmp.replaceFirst("%2s", clientViewBean.getOrganization());

                        serverResponse = metacatClient.login(posted_ldapUserName, clientViewBean.getPassword());

                        setLoggedIn(serverResponse);

                        message = parseXml("message", serverResponse);

                        contactName = parseXml("name", serverResponse);

                        clientViewBean.setMessage(ClientView.LOGIN_MESSAGE, message);

                        clientViewBean.setMessage(ClientView.UPLOAD_MESSAGE, "");

                        if (isLoggedIn()) {

                            clientViewBean.setSessionid(metacatClient.getSessionId());

                        }

                        //*** Now that the action has been processed, clear it.

                        clientViewBean.setAction("");

                    } else if (action.equals("Logout")) {

                        message = metacatClient.logout();

                        setLoggedIn(message);

                        message = parseXml("message", message);

                        clientViewBean.setMessage(ClientView.LOGIN_MESSAGE, message);

                        clientViewBean.setMessage(ClientView.UPLOAD_MESSAGE, "");

                        if (!isLoggedIn()) {

                            clientViewBean.setUsername("");

                            clientViewBean.setPassword("");

                            clientViewBean.setOrganization("");

                            clientViewBean.setSessionid(null);

                        }

                        //*** Now that the action has been processed, clear it.

                        clientViewBean.setAction("");

                    } else if (action.equals("Delete")) {

                        ClientFgdcHelper.clientDeleteRequest(clientViewBean, this);

                        clientViewBean.setAction("read"); //*** Set for re-query.

                        //*** Note: the clientViewBean will already have the updated Meta Doc Id.

                    } else if (action.equals("Upload")) {

                        message = "";

                        //*** Only process request if a file upload.

                        if (isLoggedIn()) {

                            //*** Init the MultipartParser.

                            multipartParser = new MultipartParser(request, sizeLimit * 1024 * 1024);

                            message = handlePackageUpload(clientViewBean, multipartParser);

                        }

                        clientViewBean.setMessage(ClientView.UPLOAD_MESSAGE, message);

                        //*** Now that the action has been processed, clear it.

                        clientViewBean.setAction("");

                    } else if (action.equals("Update")) {

                        System.out.println("This is not implemented here.  Call ClientViewHelper.jspx");

                    } else if (action.equals("Scope")) {

                        message = handleDocIdSelect();

                        clientViewBean.setMessage(ClientView.SELECT_MESSAGE, message);

                    } else if (action.equals("Download")) {

                        System.out.println("ClientViewHelper.clientRequest: action = " + action);

                        download(clientViewBean, response);

                    }

                } catch (Exception ex) {

                    message = ex.getMessage();

                    clientViewBean.setMessage(ClientView.ERROR_MESSAGE, message);

                    ex.printStackTrace();

                }

            }

        } else {

            System.out.println("ClientViewHelper.clientRequest: ClientView bean is not instantiated.");

        }

        return(result);

    }

    /**

     * This is a convenience method to reduce the amount of code in a Metacat Client.

     * It handles creating/reusing (per session) an instance of a ClientViewHelper.

     * @param request Since this is intended to be used by an Http client, it is passed the

     * available "request" variable (the HttpServletRequest).

     * @throws edu.ucsb.nceas.metacat.client.MetacatInaccessibleException Received by MetacatFactory.

     * @return ClientViewHelper instance.

     */

    public static ClientViewHelper clientViewHelperInstance(HttpServletRequest request) {

        ClientViewHelper                        result;

        result = (ClientViewHelper) request.getSession().getAttribute("ClientViewHelper");

        if (result == null) {

            try {

                result = new ClientViewHelper(request);

                request.getSession().setAttribute("ClientViewHelper", result);

            } catch (MetacatInaccessibleException ex) {

                ex.printStackTrace();

            }

        }

        return(result);

    }

    /**

     * A convenience method to be used by client code that requires

     * the user to be logged in.  NOTE: setUser() must have been called first,

     * otherwise it will always return false.

     * @return boolean  true if user has logged in for this session, false otherwise.

     */

    public boolean isLoggedIn() {

        return(loggedIn);

    }

    /**

     * After calling "login(ldapUserName, pwd)", call this with the username

     * and servers response message.  You can than use isLoggedIn() to determine if

     * the user is logged in, getLoginResponseElement(), etc.  The user name will also

     * used by calls to doMetadataUpload() for Document Id creation (scope).

     * @param userName User name

     * @param serverResponse XML login response sent from Metacat.

     */

    public void setLoggedIn(String serverResponse) {

        loggedIn = (serverResponse != null && serverResponse.contains("login"));

    }

    public String parseXml(String elementName, String xml) {

        String                      result = null;

        Document                    doc;

        try {

            doc = XMLUtilities.getXMLReaderAsDOMDocument(new StringReader(xml));

            result = (String) xpath.evaluate(elementName, doc.getDocumentElement(), XPathConstants.STRING);

            if (result != null)

                result = result.trim();

        } catch (IOException ex) {

            ex.printStackTrace();

        } catch (XPathExpressionException ex) {

            ex.printStackTrace();

        }

        return(result);

    }

    public String handleDocIdSelect() {

        String                              result = "";

        TreeMap                             allDocIds;

        if (!clientViewBean.getPathValue().equals("")) {

            allDocIds = getSelectQueryMap();

            result = ClientHtmlHelper.mapToHtmlSelect(allDocIds, "docId", "width: 240", 10);

        }

        return(result);

    }

    /**

     * Handles metadata file and data file uploads for inserting new

     * Metacat data packages.  Note: if content type is not "multipart/form-data",

     * nothing will happen.

     * @param request HTTP request.

     * @return A 1-line status message for the user.

     */

    public String handlePackageUpload(ClientView clientViewBean, MultipartParser multipartParser) throws Exception {

        String                      result = "", contentType, formatType;

        String                      lastDocId, nextDocId, metaDocId, metaFileName;

        String                      fileInfo[];

        Reader                      reader;

        int                         sizeLimit, idx;

        InputStream                 inputStream;

        HashMap                     paramsMap, dataDocIDs;

        StringBuffer                fileName;

        boolean                     sendIt;

        //*** Get the First file, which should be the metadata file.

        paramsMap = new HashMap();

        fileName = new StringBuffer();

        inputStream = getNextInputStream(multipartParser, fileName, paramsMap);

        metaFileName = fileName.toString();

        if (metaFileName.toLowerCase().endsWith(".xml")) {

            //*** Keep it here for updating.

            setMetadataDoc(inputStream);

            //*** Get the Metadata File's DOC ID.

            lastDocId = getMetacatClient().getLastDocid(clientViewBean.getUsername());

            metaDocId = lastDocId = nextDocId(lastDocId, clientViewBean.getUsername());

            //*** Loop thru all of the data files, get fileName and inputStream.

            dataDocIDs = new HashMap();

            fileName = new StringBuffer();

            while ((inputStream = getNextInputStream(multipartParser, fileName, paramsMap)) != null) {

                //*** Get the data file's DOC ID.

                nextDocId = nextDocId(lastDocId, clientViewBean.getUsername());

                fileInfo = parseFileInfo(fileName.toString());

                dataDocIDs.put(nextDocId, fileInfo);

                //*** Upload the data file to metacat.

                getMetacatClient().upload(nextDocId, fileName.toString(), inputStream, Integer.MAX_VALUE);

                lastDocId = nextDocId;

                fileName = new StringBuffer();

            }

            if (ClientFgdcHelper.isFGDC(getMetadataDoc())) {

                sendIt = ClientFgdcHelper.handlePackageUpload(metaDocId, dataDocIDs, contactName, metaFileName, getMetadataDoc());

            } else {

                //TODO add other types of metadata grammars here...

                System.out.println("ClientViewHelper.handlePackageUpload: not an FGDC file = " + fileName);

                result = fileName + " is not an FGDC file.  Files not uploaded.";

                sendIt = false;

            }

            if (sendIt) {

                //*** Upload the metadata file to metacat.

                reader = XMLUtilities.getDOMTreeAsReader(metadataDoc.getDocumentElement(), false);

                getMetacatClient().insert(metaDocId, reader, null);

                result = "MetaCat Package Inserted:  the Document Identifier is " + metaDocId;

                reader.close();

                //*** One last detail...grant the public read access.

                if (paramsMap.containsKey("publicAccess"))

                    getMetacatClient().setAccess(metaDocId, "public", "read", "allow", "allowFirst");

            }

        } else {

            result = "The first file must be an XML Metadata file.  Files not uploaded.";

        }

        if (inputStream != null)

            inputStream.close();

        return(result);

    }

    public String handleFileUpdate(MultipartParser multipartParser) throws Exception {

        String                      result = "", fNm, action, lastDocId, newDocId, xPathQuery, qFrmt;

        InputStream                 inputStream;

        HashMap                     paramsMap;

        StringBuffer                fileName;

        Iterator                    iterIt;

        boolean                     sendIt;

        String                      metadataDocId, fileInfo[];

        paramsMap = new HashMap();

        fileName = new StringBuffer();

        if ((inputStream = getNextInputStream(multipartParser, fileName, paramsMap)) != null) {

            action = (String) paramsMap.get("action");

            //*** Get the Doc Id.

            lastDocId = (String) paramsMap.get("docid");

            //*** Get the metadata Doc Id.

            metadataDocId = (String) paramsMap.get("metadataDocId");

            //*** Get the qformat.

            qFrmt = (String) paramsMap.get("qformat");

            fNm = fileName.toString();

            try {

                if (lastDocId.equals(metadataDocId)) { //*** This is the metadata file.

                    //*** Keep it here for updating.

                    setMetadataDoc(inputStream);

                    if (ClientFgdcHelper.isFGDC(getMetadataDoc())) {

                        clientViewBean.setContentStandard(ClientView.FEDERAL_GEOGRAPHIC_DATA_COMMITTEE);

                        if (!ClientFgdcHelper.hasMetacatInfo(lastDocId, getMetadataDoc())) {

                            //*** Save the Doc Id for re-query.

                            clientViewBean.setMetaFileDocId(lastDocId);

                            clientViewBean.setAction("read"); //*** Set for re-query.

                            result = "Update not performed: the Metadata file has no prior Metacat info in it.";

                        } else {

                            xPathQuery = ClientFgdcHelper.XPATH_QUERY_TEMPLATE.replaceFirst("%1s", lastDocId);

                            newDocId = updateMetadataDoc(lastDocId, xPathQuery, fNm);

                            //*** Save the Doc Id for re-query.

                            clientViewBean.setMetaFileDocId(newDocId);

                            clientViewBean.setAction("read"); //*** Set for re-query.

                            //result = makeRedirectUrl(newDocId, qFrmt);

                            result = "Updated to new document (from " + lastDocId + " to " + newDocId + ")";

                        }

                    } else {

                        //***TODO This is EML.

                        clientViewBean.setContentStandard(ClientView.ECOLOGICAL_METADATA_LANGUAGE);

                        //*** Save the Doc Id for re-query.

                        clientViewBean.setMetaFileDocId(lastDocId);

                        clientViewBean.setAction("read"); //*** Set for re-query.

                        result = "Currently this functionality only supports FGDC metadata.";

                    }

                } else {

                    //*** This is a data file.

                    //*** Query for the metadata, we need to update it with the new data file doc id.

                    setMetadataDoc(metadataDocId);

                    if (ClientFgdcHelper.isFGDC(getMetadataDoc())) {

                        clientViewBean.setContentStandard(ClientView.FEDERAL_GEOGRAPHIC_DATA_COMMITTEE);

                        fileInfo = parseFileInfo(fNm);

                        xPathQuery = ClientFgdcHelper.FGDC_DATA_FILE_QUERY_XPATH.replaceFirst("%1s", lastDocId);

                        newDocId = nextVersion(lastDocId, xPathQuery);

                        ClientFgdcHelper.updateFileNameAndType(getMetadataDoc().getDocumentElement(), newDocId, fileInfo);

                        //*** Upload the data file to metacat.

                        result = getMetacatClient().upload(newDocId, fNm, inputStream, Integer.MAX_VALUE);

                        System.out.println("ClientViewHelper.handleFileUpdate: upload returned " + result);

                        //*** Upload the metadata file to metacat.

                        xPathQuery = ClientFgdcHelper.XPATH_QUERY_TEMPLATE.replaceFirst("%1s", metadataDocId);

                        newDocId = updateMetadataDoc(metadataDocId, xPathQuery, null);

                        //*** Save the new meta Doc Id for re-query.

                        clientViewBean.setMetaFileDocId(newDocId);

                        clientViewBean.setAction("read"); //*** Set for re-query.

                        //result = makeRedirectUrl(newDocId, qFrmt);

                        result = "Updated to new document (from " + lastDocId + " to " + newDocId + ")";

                    } else {

                        //***TODO This is EML.

                        clientViewBean.setContentStandard(ClientView.ECOLOGICAL_METADATA_LANGUAGE);

                        //*** Save the old meta Doc Id for re-query.

                        clientViewBean.setMetaFileDocId(metadataDocId);

                        clientViewBean.setAction("read"); //*** Set for re-query.

                        result = "Currently this functionality only supports FGDC metadata.";

                    }

                }

            } catch (java.io.IOException ex) {

                ex.printStackTrace();

            }

        } else {

            result = "Please enter the updated file path/name.";

        }

        clientViewBean.setMessage(ClientView.UPDATE_MESSAGE, result);

        return(result);

    }

    private String updateMetadataDoc(String lastDocId, String docIdPath, String origFileName) {

        String                      newDocId = null;

        Reader                      reader;

        //*** Update the metadata with the new Doc Id version.

        try {

            newDocId = nextVersion(lastDocId, docIdPath);

            if (origFileName != null) {

                if (clientViewBean.getContentStandard().equals(ClientView.FEDERAL_GEOGRAPHIC_DATA_COMMITTEE))

                    ClientFgdcHelper.updateMetadataFileName(getMetadataDoc().getDocumentElement(), newDocId, origFileName);

                else

                    ; //TODO EML, etc.

            }

            //*** Upload the metadata file to metacat.

            reader = XMLUtilities.getDOMTreeAsReader(getMetadataDoc().getDocumentElement(), false);

            getMetacatClient().update(newDocId, reader, null);

            reader.close();

        } catch (Exception ex) {

            ex.printStackTrace();

        }

        return(newDocId);

    }

    private InputStream getNextInputStream(MultipartParser multipartParser, StringBuffer fileName, HashMap paramsMap)

    throws IOException {

        InputStream                     result = null;

        Part                            part;

        String                          parmName = null, value = null, fnam;

        while ((part = multipartParser.readNextPart()) != null) {

            if (part.isParam()) {

                parmName = part.getName();

                value = ((ParamPart) part).getStringValue();

                paramsMap.put(parmName, value);

                System.out.println("ClientViewHelper.getNextInputStream: parmName = " + parmName + "  value = " + value);

            } else if (part.isFile()) {

                fnam = ((FilePart) part).getFileName();

                if (fnam != null && !fnam.equals("")) {

                    //*** File name is passed back via StringBuffer fileName param.

                    fileName.append(fnam);

                    result = ((FilePart) part).getInputStream();

                    System.out.println("ClientViewHelper.getNextInputStream: fileName = " + fileName + "  inputStream = " + result.toString());

                    break;

                }

            }

        }

        return(result);

    }

    private void getRemainingParameters(MultipartParser multipartParser, HashMap paramsMap)

    throws IOException {

        InputStream                     result = null;

        Part                            part;

        String                          parmName = null, value = null, fnam;

        while ((part = multipartParser.readNextPart()) != null) {

            if (part.isParam()) {

                parmName = part.getName();

                value = ((ParamPart) part).getStringValue();

                paramsMap.put(parmName, value);

                System.out.println("ClientViewHelper.getNextInputStream: parmName = " + parmName + "  value = " + value);

            }

        }

    }

    /**

     * Queries Metacat for document listings, and returns the results in a TreeMap,

     * where the key is the Doc Id, and the value is the Create Date.  If the document

     * contains the specified 'returnfield', an addtional entry will be created with

     * the value being a Vector of sub-DocId's.  The key of this entry will be the

     * original DocId with some addtional text added.

     * Reads bean properties 'pathExpr' (String[]), 'pathValue' (String)

     * and 'returnfield' (String).

     * @return TreeMap

     */

    public TreeMap getSelectQueryMap() {

        TreeMap                         result;

        Document                        doc;

        NodeList                        nodeLst, subNodeLst;

        Node                            node, subNode;

        String                          key, val, paramExpr, paramVal;

        String                          value, returnFld;

        String                          path;

        Vector                          optGroup;

        final String                    DOCID_EXPR = "./docid";

        final String                    DOCNAME_EXPR = "./createdate";

        final String                    PARAM_EXPR = "./param[@name='%1s']";

        path = clientViewBean.getPathExpr();

        returnFld = clientViewBean.getReturnfield();

        value = clientViewBean.getPathValue();

        result = new TreeMap();

        //paramExpr = String.format(PARAM_EXPR, returnFld);

        paramExpr = PARAM_EXPR.replaceFirst("%1s", returnFld);

        //*** Query the database ***

        doc = query(path, value, returnFld);

        //*** Build the TreeMap to return ***

        try {

            nodeLst = (NodeList) xpath.evaluate("/resultset/document", doc, XPathConstants.NODESET);

            for (int i = 0; i < nodeLst.getLength(); i++) {

                node = nodeLst.item(i);

                key = xpath.evaluate(DOCID_EXPR, node);

                val = xpath.evaluate(DOCNAME_EXPR, node);

                result.put(key, key + " (" + val + ")");

                //*** returnfield values ***

                subNodeLst = (NodeList) xpath.evaluate(paramExpr, node, XPathConstants.NODESET);

                if (subNodeLst.getLength() > 0) {

                    optGroup = new Vector();

                    for (int k = 0; k < subNodeLst.getLength(); k++) {

                        subNode =  subNodeLst.item(k);

                        paramVal = xpath.evaluate("text()", subNode);

                        optGroup.add(paramVal);

                    }

                    result.put(key + " Data Files", optGroup);

                }

            }

        } catch (XPathExpressionException ex) {

            ex.printStackTrace();

        }

        return(result);

    }

    /**

     * Query metacat for documents that 'CONTAINS' the value at the specified XPath

     * expression.  Additionally, returns another non-standard field value.

     * Standard info contains: DocId, DocName, DocType, CreateDate, and UpdateDate.

     * @param pathExpr String contianing an XPath expression.

     * @param pathValue String containing a comparison value at the XPath expression.

     * @param returnFld String containing an XPath expression to a field which will be returned

     * in addition to the standard info.

     * @return DOM Document containing the results.

     */

    public Document query(String pathExpr, String pathValue, String returnFld) {

        Document                        result = null;

        InputStream                     response;

        BufferedReader                  buffy;

        Properties                      prop;

        try {

            prop = new Properties();

            prop.put("action", "query");

            prop.put("qformat", "xml");

            prop.put(pathExpr, pathValue);

            if (returnFld != null) {

                prop.put("returnfield", returnFld);

            }

            response = metacatClient.sendData(prop, null, null, 0);

            if (response != null) {

                buffy = new BufferedReader(new InputStreamReader(response));

                result = XMLUtilities.getXMLReaderAsDOMDocument(buffy);

            }

        } catch (IOException ex) {

            ex.printStackTrace();

        } catch (Exception ex) {

            ex.printStackTrace();

        }

        return(result);

    }

    public void setMetadataDoc(Document doc) {

        metadataDoc = doc;

    }

    public void setMetadataDoc(String docId) throws Exception {

        Document                        doc = null;

        BufferedReader                  buffy;

        Properties                      prop;

        InputStream                     response;

        //*** MetaCatServlet Properties: action, qformat and docid. ***

        prop = new Properties();

        prop.put("action", "read");

        prop.put("qformat", "xml");

        prop.put("docid", docId);

        response = metacatClient.sendData(prop, null, null, 0);

        if (response != null) {

            buffy = new BufferedReader(new InputStreamReader(response));

            doc = XMLUtilities.getXMLReaderAsDOMDocument(buffy);

            response.close();

        }

        setMetadataDoc(doc);

    }

    public void setMetadataDoc(InputStream ioStream) throws IOException {

        BufferedReader                          buffy;

        if (ioStream != null) {

            buffy = new BufferedReader(new InputStreamReader(ioStream));

            metadataDoc = XMLUtilities.getXMLReaderAsDOMDocument(buffy);

        }

    }

    public Document getMetadataDoc() {

        return(metadataDoc);

    }

    public String nextVersion(String lastDocId, String xPathQuery) throws XPathExpressionException {

        String                      result = null, tokens[], scope, ready2Split, tmp;

        int                         vers, docNum;

        final int                   LAST_TOKEN = 2;

        final String                TEMPLATE = "%1s.%2d.%3d";

        Node                        node;

        //*** Parse the last Doc Id, and increment the version number.

        if(lastDocId != null && lastDocId.contains(".")) {

            ready2Split = lastDocId.replace('.','~'); //*** This is necessary for the split to work.

            tokens = ready2Split.split("~");

            if(tokens.length > LAST_TOKEN && !tokens[LAST_TOKEN].equals("")) {

                scope = tokens[LAST_TOKEN - 2];

                docNum = Integer.parseInt(tokens[LAST_TOKEN - 1]);

                try {

                    vers = Integer.parseInt(tokens[LAST_TOKEN]);

                    //result = String.format(TEMPLATE, scope, docNum, 1 + vers);

                    tmp = TEMPLATE.replaceFirst("%1s", scope);

                    tmp = tmp.replaceFirst("%2d", String.valueOf(docNum));

                    result = tmp.replaceFirst("%3d", String.valueOf(vers + 1));

                } catch (NumberFormatException ex) {

                    //*** In case the lastDocId has something other than a number.

                    //result = String.format(TEMPLATE, scope, docNum, 1);

                    tmp = TEMPLATE.replaceFirst("%1s", scope);

                    tmp = tmp.replaceFirst("%2d", String.valueOf(docNum));

                    result = tmp.replaceFirst("%3d", "1");

                }

            } else {

                //*** In case the lastDocId ends with a '.'

                result = lastDocId + "1";

            }

        } else {

            //*** In case of missing doc Id.

            result = null;

        }

        //*** Update the Doc Id in the metadata file.

        if (getMetadataDoc() != null) {

            node = (Node) xpath.evaluate(xPathQuery, getMetadataDoc().getDocumentElement(), XPathConstants.NODE);

            node.setTextContent(result);

        }

        return(result);

    }

    private String nextDocId(String lastDocId, String scope) {

        String                      result = null, tokens[], tmp;

        int                         vers;

        String                      template = scope.toLowerCase() + ".%1d.%2d";

        if(lastDocId != null && lastDocId.contains(".")) {

            lastDocId = lastDocId.replace('.','~'); //*** This is necessary for the split to work.

            tokens = lastDocId.split("~");

            if(tokens.length > 1 && !tokens[1].equals("")) {

                try {

                    vers = Integer.parseInt(tokens[1]);

                    //result = String.format(template, 1 + vers, 1);

                    tmp = template.replaceFirst("%1d", String.valueOf(1 + vers));

                    result = tmp.replaceFirst("%2d", "1");

                } catch (NumberFormatException ex) {

                    //*** In case the lastDocId has something other than a number.

                    //result = String.format(template, 1, 1);

                    tmp = template.replaceFirst("%1d", "1");

                    result = tmp.replaceFirst("%2d", "1");

                }

            } else {

                //*** In case the lastDocId ends with a '.'

                //result = String.format(template, 1, 1);

                tmp = template.replaceFirst("%1d", "1");

                result = tmp.replaceFirst("%2d", "1");

            }

        } else {

            //*** In case there isn't any doc Id's with the user name.

            //result = String.format(template, 1, 1);

            tmp = template.replaceFirst("%1d", "1");

            result = tmp.replaceFirst("%2d", "1");

        }

        return(result);

    }

    public MetacatClient getMetacatClient() {

        return(metacatClient);

    }

    //*** BEGIN: Static utility methods ***

    public static String[] parseFileInfo(String fileName) {

        String[]                        result = new String[2];

        int                             idx;

        String                          formatType;

        //*** Set the file format (just using file extension for now).

        idx = fileName.lastIndexOf(".");

        if (idx > 1)

            formatType = fileName.substring(idx+1).toUpperCase();

        else

            formatType = "";

        result[ClientView.FORMAT_TYPE] = formatType;

        result[ClientView.FILE_NAME] = fileName.toString();

        return(result);

    }

    public static void updateNodeText(Node root, XPath xPath, String expression, String text) {

        Node                    targetNode;

        if (text != null && !text.equals("")) {

            try {

                targetNode = (Node) xPath.evaluate(expression, root, XPathConstants.NODE);

                targetNode.setTextContent(text);

            } catch (XPathExpressionException ex) {

                ex.printStackTrace();

            }

        }

    }

    public static Node getNode(XPath xPath, String expression, Node root) {

        Node                        result = null;

        try {

            result = (Node) xPath.evaluate(expression, root, XPathConstants.NODE);

        } catch (XPathExpressionException ex) {

            ex.printStackTrace();

        }

        return(result);

    }

    public static String getNodeText(XPath xPath, String expression, Node root) {

        Node                        node;

        String                      result = null;

        node = getNode(xPath, expression, root);

        if (node != null && !node.equals(""))

            result = node.getTextContent();

        return(result);

    }

    public static String[] getNodeTextList(XPath xPath, String expression, Node root) {

        NodeList                    nodes;

        String                      result[] = null;

        int                         size;

        try {

            nodes = (NodeList) xPath.evaluate(expression, root, XPathConstants.NODESET);

            if (nodes != null && (size = nodes.getLength()) > 0) {

                result = new String[size];

                for(int i = 0; i < size; i++)

                    result[i] = nodes.item(i).getTextContent();

            }

        } catch (XPathExpressionException ex) {

            ex.printStackTrace();

        }

        return(result);

    }

    public static String getStringFromInputStream(InputStream input) {

        StringBuffer result = new StringBuffer();

        BufferedReader in = new BufferedReader(new InputStreamReader(input));

        String line;

        try {

            while ((line = in.readLine()) != null) {

                result.append(line);

            }

        } catch (IOException e) {

            System.out.println("ClientViewHelper.getStringFromInputStream: " + e);

        }

        return result.toString();

    }

    //*** END: Static utility methods ***

    public String makeRedirectUrl() {

        String                      result, docId;