Metacat

import java.util.Map;

import java.util.TreeMap;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

    /**

     * Identifies the FGDC DTD.

     */

     * JSP API: Get the user's name.  This will be what was entered for the user name, 

     * and is not the LDAP user name.

     * @return String of the users name.

     */

    public String getUser() {

        return(user);

    }

    /**

        if (serverResponse != null && serverResponse.contains("login")) {

            System.out.println("MetacatClient.setUser: getSessionId() = " + getSessionId());

        } else {

        }

        HashMap                     dataDocIDs, paramsMap;

        ServletContext cntxt = request.getSession().getServletContext().getContext("/knb/metacat");

        String servletName = cntxt.getServletContextName();

                paramsMap = new HashMap();

                inputStream = getNextInputStream(multipartParser, fileName, paramsMap);

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

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

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

                        if (paramsMap.containsKey("publicAccess"))

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

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

    throws IOException {

                paramsMap.put(parmName, value);

    private String nextVersion(String lastDocId) {

        String                      result = null, tokens[], scope;

        int                         vers, docNum;

        final int                   LAST_TOKEN = 2;

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

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

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

            tokens = lastDocId.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);

                } catch (NumberFormatException ex) {

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

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

                }

            } else {

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

                result = lastDocId + "1";

            }

        } else {

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

            result = null;

        }

        return(result);

    }

    private static final String                SELECT_TEMPLATE = "<select name='%1$s' style='%2$s' size='%3$s'>\n%4$s</select>\n";

    private static final String                OPTION_TEMPLATE = "<option value='%1$s'>%2$s</option>\n";

    private static final String                OPTGRP_TEMPLATE = "<optgroup label='%1$s'>%2$s</optgroup>";

    private static final String                INPUT_TEMPLATE = "<input name='%1$s' value='%2$s' type='%4$s' class='%3$s' size='%5$d'/>\n";

    /**

     * JSP API: A static helper method which takes a vector (keys/values) and returns

     * an XHTML SELECT String.

     * @param vector The vector contianing the values to convert into an HTML SELECT statement.

     * @param name The name to assign the HTML SELECT, which will become the parameter name.

     * @param style Any HTML styling text.

     * @param size HTML field width.

     * @return String, XHTML for a SELECT statement.

     */

    public static String vectorToHtmlSelect(Vector vector, String name, String style, int size) {

        String                      result = "", item;

        Iterator<String>            iterIt;

        iterIt = vector.iterator();

        while(iterIt.hasNext()) {

            item = iterIt.next();

            item = String.format(OPTION_TEMPLATE, item, item);

            result += item;

        }

        result = String.format(SELECT_TEMPLATE, name, style, size, result);

        return(result);

    }

    /**

     * JSP API: A static helper method which takes a map (key, value pairs) and returns

     * an XHTML SELECT String.

     * @param map The map contianing the key, value pairs to convert into an HTML SELECT

     * statement.

     * @param name The name to assign the HTML SELECT, which will become the parameter name.

     * @param style Any HTML styling text.

     * @param size HTML field width.

     * @return String, XHTML for a SELECT statement.

     */

    public static String mapToHtmlSelect(Map map, String name, String style, int size) {

        String                      result = "", item, key, optGrp;

        Iterator<String>            iterIt;

        Object                      obj;

        Vector                      vector;

        Iterator                    completeIterIt;

        iterIt = map.keySet().iterator();

        while(iterIt.hasNext()) {

            key = iterIt.next();

            obj = map.get(key);

            if (obj instanceof String) {

                item = (String) obj;

                item = String.format(OPTION_TEMPLATE, key, item);

                result += item;

            } else if (obj instanceof Vector) {

                vector = (Vector) obj;

                optGrp = "";

                completeIterIt = vector.iterator();

                while (completeIterIt.hasNext()) {

                    item = (String) completeIterIt.next();

                    item = String.format(OPTION_TEMPLATE, item, item);

                    optGrp += item;

                }

                item = String.format(OPTGRP_TEMPLATE, key, optGrp);

                result += item;

            }

        }

        result = String.format(SELECT_TEMPLATE, name, style, size, result);

        return(result);

    }

    /**

     * JSP API: A static helper method which takes attribute values and returns

     * an XHTML INPUT Statement.

     * @param type The 'type attribute' of the input statement.

     * @param name The 'name attribute' of the input statement.

     * @param value The 'value attribute' of the input statement.

     * @param cssClass The CSS 'class attribute'.

     * @param fldSize HTML field width.

     * @return String, XHTML for an INPUT statement.

     */

    public static String htmlInput(String type, String name, String value, String cssClass, int fldSize) {

        String                          result;

        result = String.format(INPUT_TEMPLATE, name, value, cssClass, type, fldSize);

        return(result);

    }

    /**

     * JSP API: A static helper method which takes a key/value pair and saves

     * it in the session.

     * @param key The session attribute key name to use.

     * @param val The value to assign.

     * @param request The HttpServletRequest.

     */

    public static void setSessValue(String key, String val, HttpServletRequest request) {

        javax.servlet.http.HttpSession      session;

        session = request.getSession();

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

            session.setAttribute(key, val);

        }

    }

    /**

     * JSP API: A static helper method which takes a key and returns the

     * value.

     * @param key The session attribute key name to use.

     * @param request The HttpServletRequest.

     * @return String value.

     */

    public static String getSessValue(String key, HttpServletRequest request) {

        javax.servlet.http.HttpSession      session;

        String                              result = "";

        if (key != null && !key.equals("") && request != null) {

            session = request.getSession();

            result = (String) session.getAttribute(key);

        }

        result = (result == null ? "" : result);

        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 = 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);

    }

    /**

     * 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 request parameters 'pathExpr' (String[]), 'pathValue' (String) 

     * and 'returnfield' (String).

     * @param request HttpServletRequest.

     * @return TreeMap

     */

    public TreeMap getSelectQueryMap(HttpServletRequest request) {

        TreeMap                         result;

        Document                        doc;

        NodeList                        nodeLst, subNodeLst;

        Node                            node, subNode;

        String                          key, val, paramExpr, paramVal;

        String                          value, paths[], returnFld;

        Vector                          optGroup;

        final String                    DOCID_EXPR = "./docid";

        final String                    DOCNAME_EXPR = "./createdate";

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

        paths = (String[]) request.getParameterValues("pathExpr");

        returnFld = (String) request.getParameter("returnfield");

        value = (String) request.getParameter("pathValue");

        result = new TreeMap();

        paramExpr = String.format(PARAM_EXPR, returnFld);

        for(int j = 0; j < paths.length; j++) {

            //*** Query the database ***

            doc = query(paths[j], 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);

    }

    /**

     * JSP API: Removes the data Doc Id from the FGDC document in the Metacat database.

     * It gets the Doc Id to delete from the session (key=docId), and determines what

     * metadata file is including this file.  It then queries metacat for the parent FGDC 

     * document and removes the Doc Id from it, and reloads the new version of the FGDC 

     * document with a new revision number.  This is intended to be called after 

     * a call to MetacatClient.delete(docId).

     * @param request HttpServletRequest which contains the session.

     * @return String server response, if any.

     */

    public String removeDataDocIdFromFGDC(HttpServletRequest request) {

        String                          docId, parentDocId, result = "  ", pathToDigform, revision;

        Document                        doc;

        InputStream                     response;

        BufferedReader                  buffy;

        Properties                      prop;

        Node                            node;

        NodeList                        nodeLst;

        Reader                          reader;

        final String                    PATH4QUERY = "/metadata/distinfo/stdorder/digform/digtopt/onlinopt/computer/networka/networkr";

        final String                    PATH4ANCESTOR = PATH4QUERY + "[text()='%1$s']/ancestor::node()[name()='%2$s']";

        //*** First, determine what metadata file is including this file (if any).

        docId = getSessValue("docId", request);

        doc = query(PATH4QUERY, docId, null);

        try {

            parentDocId = xpath.evaluate("/resultset/document/docid", doc.getDocumentElement());

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

                //*** Next, get the metadata document and update the networkr node.

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

                prop = new Properties();

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

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

                prop.put("docid", parentDocId);

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

                if (response != null) {

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

                    doc = XMLUtilities.getXMLReaderAsDOMDocument(buffy);

                    //System.out.println("MetacatClinet.removeDataDocIdFromFGDC: BEFORE\n" + XMLUtilities.getDOMTreeAsString(doc.getDocumentElement()));

                    pathToDigform = String.format(PATH4ANCESTOR, docId, "digform");

                    node = (Node) xpath.evaluate(pathToDigform, doc, XPathConstants.NODE);

                    node.getParentNode().removeChild(node);

                    //System.out.println("MetacatClinet.removeDataDocIdFromFGDC: AFTER\n" + XMLUtilities.getDOMTreeAsString(doc.getDocumentElement()));

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

                    revision = nextVersion(parentDocId);

                    result += update(revision, reader, null);

                }

            }

        } catch (Exception ex) {

            ex.printStackTrace();

        }

        return(result);

    }