Changeset 27705

Show
Ignore:
Timestamp:
26.06.2013 15:31:58 (6 years ago)
Author:
sjm84
Message:

Reformatting this file

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/collection/Collection.java

    r26446 r27705  
    3636import org.greenstone.gsdl3.util.GSXML; 
    3737import org.greenstone.gsdl3.util.OAIXML; 
    38 import org.greenstone.gsdl3.util.SimpleMacroResolver; 
    3938import org.greenstone.gsdl3.util.UserContext; 
    4039import org.greenstone.gsdl3.util.XMLTransformer; 
     
    5655    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.collection.Collection.class.getName()); 
    5756 
    58     /** is this collection being tidied and therefore can support realistic book view?*/ 
     57    /** is this collection being tidied and therefore can support realistic book view? */ 
    5958    protected boolean useBook = false; 
    60     /** is this collection public or private  - public collections will  
    61         appear on the home page, whereas private collections won't*/ 
     59    /** 
     60     * is this collection public or private - public collections will 
     61     * appear on the home page, whereas private collections won't 
     62     */ 
    6263    protected boolean is_public = true; 
    6364    /** collection type : mg, mgpp or lucene */ 
     
    8182    protected ArrayList<HashMap<String, ArrayList<String>>> _securityExceptions = new ArrayList<HashMap<String, ArrayList<String>>>(); 
    8283 
    83    
    8484    protected XMLTransformer transformer = null; 
    8585 
     
    113113            return false; 
    114114        } 
    115          
     115 
    116116        macro_resolver.addMacro("_httpcollection_", this.site_http_address + "/collect/" + this.cluster_name); 
    117117 
     
    143143        this.description.setAttribute(GSXML.TYPE_ATT, col_type); 
    144144        this.description.setAttribute(GSXML.DB_TYPE_ATT, db_type); 
    145          
     145 
    146146        _globalFormat = (Element) GSXML.getChildByTagName(coll_config_xml, GSXML.FORMAT_ELEM); 
    147147        // process the metadata and display items and default library params 
     
    391391        Element service_list = (Element) GSXML.getChildByTagName(build_config_xml, GSXML.SERVICE_CLASS_ELEM + GSXML.LIST_MODIFIER); 
    392392        Element oai_service_rack = null; 
    393         if (service_list != null) { 
    394           configureServiceRackList(service_list, coll_config_xml); 
    395           oai_service_rack = GSXML.getNamedElement(service_list, GSXML.SERVICE_CLASS_ELEM, OAIXML.NAME, OAIXML.OAIPMH); 
     393        if (service_list != null) 
     394        { 
     395            configureServiceRackList(service_list, coll_config_xml); 
     396            oai_service_rack = GSXML.getNamedElement(service_list, GSXML.SERVICE_CLASS_ELEM, OAIXML.NAME, OAIXML.OAIPMH); 
    396397        } 
    397398        // collection Config may also contain manually added service racks 
     
    399400        if (service_list != null) 
    400401        { 
    401           configureServiceRackList(service_list, build_config_xml); 
    402           // this oai used in preference to one in buildConfig.xml 
    403           oai_service_rack = GSXML.getNamedElement(service_list, GSXML.SERVICE_CLASS_ELEM, OAIXML.NAME, OAIXML.OAIPMH); 
     402            configureServiceRackList(service_list, build_config_xml); 
     403            // this oai used in preference to one in buildConfig.xml 
     404            oai_service_rack = GSXML.getNamedElement(service_list, GSXML.SERVICE_CLASS_ELEM, OAIXML.NAME, OAIXML.OAIPMH); 
    404405        } 
    405406        // Check for oai 
    406407 
    407408        if (oai_service_rack != null) 
    408           { 
    409             has_oai = true; 
    410             logger.info(this.cluster_name +" has OAI services"); 
    411             // extract earliestDatestamp from the buildconfig.xml for OAI 
    412             Element metadata_list = (Element) GSXML.getChildByTagName(build_config_xml, GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER); 
    413              
    414             if (metadata_list != null) 
    415               { 
    416             NodeList children = metadata_list.getElementsByTagName(GSXML.METADATA_ELEM); 
    417             // can't do getChildNodes(), because whitespace, such as newlines, creates Text nodes 
    418             for (int i = 0; i < children.getLength(); i++) 
    419               { 
    420                 Element metadata = (Element) children.item(i); 
    421                 if (metadata.getAttribute(GSXML.NAME_ATT).equals(OAIXML.EARLIEST_DATESTAMP)) 
    422                   { 
    423                 String earliestDatestampStr = GSXML.getValue(metadata); 
    424                 if (!earliestDatestampStr.equals("")) 
    425                   { 
    426                     earliestDatestamp = Long.parseLong(earliestDatestampStr); 
    427                   } 
    428                 break; // found a metadata element with name=earliestDatestamp in buildconfig 
    429                   } 
    430               } 
    431               } 
    432              
    433             // If at the end of this, there is no value for earliestDatestamp, print out a warning 
    434             logger.warn("No earliestDatestamp in buildConfig.xml for collection: " + this.cluster_name + ". Defaulting to 0."); 
    435              
    436           } // if oai_service_rack != null 
    437      
     409        { 
     410            has_oai = true; 
     411            logger.info(this.cluster_name + " has OAI services"); 
     412            // extract earliestDatestamp from the buildconfig.xml for OAI 
     413            Element metadata_list = (Element) GSXML.getChildByTagName(build_config_xml, GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER); 
     414 
     415            if (metadata_list != null) 
     416            { 
     417                NodeList children = metadata_list.getElementsByTagName(GSXML.METADATA_ELEM); 
     418                // can't do getChildNodes(), because whitespace, such as newlines, creates Text nodes 
     419                for (int i = 0; i < children.getLength(); i++) 
     420                { 
     421                    Element metadata = (Element) children.item(i); 
     422                    if (metadata.getAttribute(GSXML.NAME_ATT).equals(OAIXML.EARLIEST_DATESTAMP)) 
     423                    { 
     424                        String earliestDatestampStr = GSXML.getValue(metadata); 
     425                        if (!earliestDatestampStr.equals("")) 
     426                        { 
     427                            earliestDatestamp = Long.parseLong(earliestDatestampStr); 
     428                        } 
     429                        break; // found a metadata element with name=earliestDatestamp in buildconfig 
     430                    } 
     431                } 
     432            } 
     433 
     434            // If at the end of this, there is no value for earliestDatestamp, print out a warning 
     435            logger.warn("No earliestDatestamp in buildConfig.xml for collection: " + this.cluster_name + ". Defaulting to 0."); 
     436 
     437        } // if oai_service_rack != null 
     438 
    438439        return true; 
    439440    } 
    440  
    441441 
    442442    /** 
     
    462462        if (subset.equals(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER) || subset.equals(GSXML.DISPLAY_TEXT_ELEM + GSXML.LIST_MODIFIER) || subset.equals("libraryParamList")) 
    463463        { 
    464           configureLocalData(coll_config_elem); 
    465           configureLocalData(build_config_elem); 
     464            configureLocalData(coll_config_elem); 
     465            configureLocalData(build_config_elem); 
    466466            return findAndLoadInfo(coll_config_elem, build_config_elem); 
    467467 
     
    481481    protected Element processMessage(Element request) 
    482482    { 
    483       String type = request.getAttribute(GSXML.TYPE_ATT); 
     483        String type = request.getAttribute(GSXML.TYPE_ATT); 
    484484        if (type.equals(GSXML.REQUEST_TYPE_FORMAT_STRING)) 
    485485        { 
    486           return processFormatStringRequest(request); 
     486            return processFormatStringRequest(request); 
    487487        } 
    488488        else if (type.equals(GSXML.REQUEST_TYPE_SECURITY)) 
    489489        { 
    490           return processSecurityRequest(request); 
     490            return processSecurityRequest(request); 
    491491        } 
    492492        else if (type.equals(GSXML.REQUEST_TYPE_FORMAT)) 
    493493        { 
     494            Element response = this.doc.createElement(GSXML.RESPONSE_ELEM); 
     495            response.setAttribute(GSXML.FROM_ATT, this.cluster_name); 
     496            response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_FORMAT); 
     497            if (_globalFormat != null) 
     498            { 
     499                response.appendChild(this.doc.importNode(_globalFormat, true)); 
     500            } 
     501            return response; 
     502        } 
     503        // unknown type 
     504        return super.processMessage(request); 
     505 
     506    } 
     507 
     508    protected Element processSecurityRequest(Element request) 
     509    { 
    494510        Element response = this.doc.createElement(GSXML.RESPONSE_ELEM); 
    495511        response.setAttribute(GSXML.FROM_ATT, this.cluster_name); 
    496         response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_FORMAT); 
    497             if(_globalFormat != null) 
    498             { 
    499                 response.appendChild(this.doc.importNode(_globalFormat, true)); 
    500             } 
    501             return response; 
    502         } 
    503         // unknown type 
    504         return super.processMessage(request); 
    505  
    506     } 
    507  
    508   protected Element processSecurityRequest(Element request) { 
    509     Element response = this.doc.createElement(GSXML.RESPONSE_ELEM); 
    510     response.setAttribute(GSXML.FROM_ATT, this.cluster_name); 
    511     response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_SECURITY); 
    512      
    513     String oid = request.getAttribute("oid"); 
    514     if (oid.contains(".")) 
    515       { 
    516     oid = oid.substring(0, oid.indexOf(".")); 
    517       } 
    518      
    519     ArrayList<String> groups = getPermittedGroups(oid); 
    520      
    521     Element groupList = this.doc.createElement(GSXML.GROUP_ELEM + GSXML.LIST_MODIFIER); 
    522     response.appendChild(groupList); 
    523      
    524     for (String groupName : groups) 
    525       { 
    526     Element group = this.doc.createElement(GSXML.GROUP_ELEM); 
    527     groupList.appendChild(group); 
    528     group.setAttribute(GSXML.NAME_ATT, groupName); 
    529       } 
    530     return response; 
    531   } 
     512        response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_SECURITY); 
     513 
     514        String oid = request.getAttribute("oid"); 
     515        if (oid.contains(".")) 
     516        { 
     517            oid = oid.substring(0, oid.indexOf(".")); 
     518        } 
     519 
     520        ArrayList<String> groups = getPermittedGroups(oid); 
     521 
     522        Element groupList = this.doc.createElement(GSXML.GROUP_ELEM + GSXML.LIST_MODIFIER); 
     523        response.appendChild(groupList); 
     524 
     525        for (String groupName : groups) 
     526        { 
     527            Element group = this.doc.createElement(GSXML.GROUP_ELEM); 
     528            groupList.appendChild(group); 
     529            group.setAttribute(GSXML.NAME_ATT, groupName); 
     530        } 
     531        return response; 
     532    } 
    532533 
    533534    protected ArrayList<String> getPermittedGroups(String oid) 
     
    681682    } 
    682683 
    683   protected Element processFormatStringRequest(Element request) { 
    684     Element response = this.doc.createElement(GSXML.RESPONSE_ELEM); 
    685     response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_FORMAT_STRING); 
    686     response.setAttribute(GSXML.FROM_ATT, this.cluster_name); 
    687  
    688     String subaction = request.getAttribute("subaction"); 
    689     String service = request.getAttribute("service"); 
    690      
    691     String classifier = null; 
    692     if (service.equals("ClassifierBrowse")) 
    693       { 
    694     classifier = request.getAttribute("classifier"); 
    695       } 
    696  
    697     // check for version file 
    698     String directory = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name)).getParent() + File.separator; 
    699  
    700     String version_filename = ""; 
    701     if (service.equals("ClassifierBrowse")) 
    702       version_filename = directory + "browse_" + classifier + "_format_statement_version.txt"; 
    703     else 
    704       version_filename = directory + "query_format_statement_version.txt"; 
    705  
    706     File version_file = new File(version_filename); 
    707  
    708     if (subaction.equals("update")) 
    709       { 
    710     Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM); 
    711     //String format_string = GSXML.getNodeText(format_element); 
    712     Element format_statement = (Element) format_element.getFirstChild(); 
    713  
    714     String version_number = "1"; 
    715     BufferedWriter writer; 
    716  
    717     try 
    718       { 
    719  
    720         if (version_file.exists()) 
    721           { 
    722         // Read version 
    723         BufferedReader reader = new BufferedReader(new FileReader(version_filename)); 
    724         version_number = reader.readLine(); 
    725         int aInt = Integer.parseInt(version_number) + 1; 
    726         version_number = Integer.toString(aInt); 
    727         reader.close(); 
    728           } 
    729         else 
    730           { 
    731         // Create 
    732         version_file.createNewFile(); 
    733         writer = new BufferedWriter(new FileWriter(version_filename)); 
    734         writer.write(version_number); 
    735         writer.close(); 
    736           } 
    737  
    738         // Write version file 
    739         String format_statement_filename = ""; 
    740  
    741         if (service.equals("ClassifierBrowse")) 
    742           format_statement_filename = directory + "browse_" + classifier + "_format_statement_v" + version_number + ".txt"; 
    743         else 
    744           format_statement_filename = directory + "query_format_statement_v" + version_number + ".txt"; 
    745  
    746         // Write format statement 
    747         String format_string = this.converter.getString(format_statement); //GSXML.xmlNodeToString(format_statement); 
    748         writer = new BufferedWriter(new FileWriter(format_statement_filename)); 
    749         writer.write(format_string); 
    750         writer.close(); 
    751  
    752         // Update version number 
    753         writer = new BufferedWriter(new FileWriter(version_filename)); 
    754         writer.write(version_number); 
    755         writer.close(); 
    756  
    757       } 
    758     catch (IOException e) 
    759       { 
    760         logger.error("IO Exception " + e); 
    761       } 
    762       } 
    763  
    764     if (subaction.equals("saveDocument")) 
    765       { 
    766     Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM); 
    767     //String format_string = GSXML.getNodeText(format_element); 
    768     // Get display tag 
    769     Element display_format = (Element) format_element.getFirstChild(); 
    770  
    771     String collection_config = directory + "collectionConfig.xml"; 
    772     Document config = this.converter.getDOM(new File(collection_config), "UTF-8"); 
    773  
    774     Node current_node = GSXML.getChildByTagName(config, "CollectionConfig"); 
    775  
    776     // Get display child 
    777     if (GSXML.getChildByTagName(current_node, "display") == null) 
    778       { 
    779         // well then create a format tag 
    780         Element display_tag = config.createElement("display"); 
    781         current_node = (Node) current_node.appendChild(display_tag); 
    782       } 
    783     else 
    784       { 
    785         current_node = GSXML.getChildByTagName(current_node, "display"); 
    786       } 
    787  
    788     if (GSXML.getChildByTagName(current_node, "format") == null) 
    789       { 
    790         // well then create a format tag 
    791         Element format_tag = config.createElement("format"); 
    792         current_node.appendChild(format_tag); 
    793       } 
    794  
    795     current_node.replaceChild(config.importNode(display_format, true), GSXML.getChildByTagName(current_node, "format")); 
    796  
    797     String new_config = this.converter.getString(config); 
    798  
    799     new_config = StringUtils.replace(new_config, "&lt;", "<"); 
    800     new_config = StringUtils.replace(new_config, "&gt;", ">"); 
    801     new_config = StringUtils.replace(new_config, "&quot;", "\""); 
    802  
    803     try 
    804       { 
    805         // Write to file (not original! for now) 
    806         BufferedWriter writer = new BufferedWriter(new FileWriter(collection_config + ".new")); 
    807         writer.write(new_config); 
    808         writer.close(); 
    809       } 
    810     catch (IOException e) 
    811       { 
    812         logger.error("IO Exception " + e); 
    813       } 
    814       } 
    815  
    816     if (subaction.equals("save")) 
    817       { 
    818     Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM); 
    819     Element format_statement = (Element) format_element.getFirstChild(); 
    820  
    821     try 
    822       { 
    823         // open collectionConfig.xml and read in to w3 Document 
    824         String collection_config = directory + "collectionConfig.xml"; 
    825         Document config = this.converter.getDOM(new File(collection_config), "UTF-8"); 
    826  
    827         //String tag_name = ""; 
    828         int k; 
    829         int index; 
    830         Element elem; 
    831         // Try importing entire tree to this.doc so we can add and remove children at ease 
    832         //Node current_node = this.doc.importNode(GSXML.getChildByTagName(config, "CollectionConfig"),true); 
    833         Node current_node = GSXML.getChildByTagName(config, "CollectionConfig"); 
    834         NodeList current_node_list; 
    835  
    836         if (service.equals("ClassifierBrowse")) 
    837           { 
    838         //tag_name = "browse"; 
    839         // if CLX then need to look in <classifier> X then <format> 
    840         // default is <browse><format> 
    841  
    842         current_node = GSXML.getChildByTagName(current_node, "browse"); 
    843  
    844         // find CLX 
    845         if (classifier != null) 
    846           { 
    847             current_node_list = GSXML.getChildrenByTagName(current_node, "classifier"); 
    848             index = Integer.parseInt(classifier.substring(2)) - 1; 
    849  
    850             // index should be given by X-1 
    851             current_node = current_node_list.item(index); 
    852             // what if classifier does not have a format tag? 
    853             if (GSXML.getChildByTagName(current_node, "format") == null) 
    854               { 
    855             // well then create a format tag 
    856             Element format_tag = config.createElement("format"); 
    857             current_node.appendChild(format_tag); 
    858               } 
    859           } 
     684    protected Element processFormatStringRequest(Element request) 
     685    { 
     686        Element response = this.doc.createElement(GSXML.RESPONSE_ELEM); 
     687        response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_FORMAT_STRING); 
     688        response.setAttribute(GSXML.FROM_ATT, this.cluster_name); 
     689 
     690        String subaction = request.getAttribute("subaction"); 
     691        String service = request.getAttribute("service"); 
     692 
     693        String classifier = null; 
     694        if (service.equals("ClassifierBrowse")) 
     695        { 
     696            classifier = request.getAttribute("classifier"); 
     697        } 
     698 
     699        // check for version file 
     700        String directory = new File(GSFile.collectionConfigFile(this.site_home, this.cluster_name)).getParent() + File.separator; 
     701 
     702        String version_filename = ""; 
     703        if (service.equals("ClassifierBrowse")) 
     704            version_filename = directory + "browse_" + classifier + "_format_statement_version.txt"; 
    860705        else 
    861           { 
    862             // To support all classifiers, set classifier to null?  There is the chance here that the format tag does not exist 
    863             if (GSXML.getChildByTagName(current_node, "format") == null) 
    864               { 
    865             // well then create a format tag 
    866             Element format_tag = config.createElement("format"); 
    867             current_node.appendChild(format_tag); 
    868               } 
    869           } 
    870           } 
    871         else if (service.equals("AllClassifierBrowse")) 
    872           { 
    873         current_node = GSXML.getChildByTagName(current_node, "browse"); 
    874         if (GSXML.getChildByTagName(current_node, "format") == null) 
    875           { 
    876             // well then create a format tag 
    877             Element format_tag = config.createElement("format"); 
    878             current_node.appendChild(format_tag); 
    879           } 
    880           } 
    881         else 
    882           { 
    883         // look in <format> with no attributes 
    884         current_node_list = GSXML.getChildrenByTagName(current_node, "search"); 
    885         for (k = 0; k < current_node_list.getLength(); k++) 
    886           { 
    887             current_node = current_node_list.item(k); 
    888             // if current_node has no attributes then break 
    889             elem = (Element) current_node; 
    890             if (elem.hasAttribute("name") == false) 
    891               break; 
    892           } 
    893           } 
    894  
    895         current_node.replaceChild(config.importNode(format_statement, true), GSXML.getChildByTagName(current_node, "format")); 
    896  
    897         // Now convert config document to string for writing to file 
    898         String new_config = this.converter.getString(config); 
    899  
    900         new_config = StringUtils.replace(new_config, "&lt;", "<"); 
    901         new_config = StringUtils.replace(new_config, "&gt;", ">"); 
    902         new_config = StringUtils.replace(new_config, "&quot;", "\""); 
    903  
    904         // Write to file (not original! for now) 
    905         BufferedWriter writer = new BufferedWriter(new FileWriter(collection_config + ".new")); 
    906         writer.write(new_config); 
    907         writer.close(); 
    908  
    909       } 
    910     catch (Exception ex) 
    911       { 
    912         logger.error("There was an exception " + ex); 
    913  
    914         StringWriter sw = new StringWriter(); 
    915         PrintWriter pw = new PrintWriter(sw, true); 
    916         ex.printStackTrace(pw); 
    917         pw.flush(); 
    918         sw.flush(); 
    919         logger.error(sw.toString()); 
    920       } 
    921  
    922       } 
    923  
    924     return response; 
    925   } 
     706            version_filename = directory + "query_format_statement_version.txt"; 
     707 
     708        File version_file = new File(version_filename); 
     709 
     710        if (subaction.equals("update")) 
     711        { 
     712            Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM); 
     713            //String format_string = GSXML.getNodeText(format_element); 
     714            Element format_statement = (Element) format_element.getFirstChild(); 
     715 
     716            String version_number = "1"; 
     717            BufferedWriter writer; 
     718 
     719            try 
     720            { 
     721 
     722                if (version_file.exists()) 
     723                { 
     724                    // Read version 
     725                    BufferedReader reader = new BufferedReader(new FileReader(version_filename)); 
     726                    version_number = reader.readLine(); 
     727                    int aInt = Integer.parseInt(version_number) + 1; 
     728                    version_number = Integer.toString(aInt); 
     729                    reader.close(); 
     730                } 
     731                else 
     732                { 
     733                    // Create 
     734                    version_file.createNewFile(); 
     735                    writer = new BufferedWriter(new FileWriter(version_filename)); 
     736                    writer.write(version_number); 
     737                    writer.close(); 
     738                } 
     739 
     740                // Write version file 
     741                String format_statement_filename = ""; 
     742 
     743                if (service.equals("ClassifierBrowse")) 
     744                    format_statement_filename = directory + "browse_" + classifier + "_format_statement_v" + version_number + ".txt"; 
     745                else 
     746                    format_statement_filename = directory + "query_format_statement_v" + version_number + ".txt"; 
     747 
     748                // Write format statement 
     749                String format_string = this.converter.getString(format_statement); //GSXML.xmlNodeToString(format_statement); 
     750                writer = new BufferedWriter(new FileWriter(format_statement_filename)); 
     751                writer.write(format_string); 
     752                writer.close(); 
     753 
     754                // Update version number 
     755                writer = new BufferedWriter(new FileWriter(version_filename)); 
     756                writer.write(version_number); 
     757                writer.close(); 
     758 
     759            } 
     760            catch (IOException e) 
     761            { 
     762                logger.error("IO Exception " + e); 
     763            } 
     764        } 
     765 
     766        if (subaction.equals("saveDocument")) 
     767        { 
     768            Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM); 
     769            //String format_string = GSXML.getNodeText(format_element); 
     770            // Get display tag 
     771            Element display_format = (Element) format_element.getFirstChild(); 
     772 
     773            String collection_config = directory + "collectionConfig.xml"; 
     774            Document config = this.converter.getDOM(new File(collection_config), "UTF-8"); 
     775 
     776            Node current_node = GSXML.getChildByTagName(config, "CollectionConfig"); 
     777 
     778            // Get display child 
     779            if (GSXML.getChildByTagName(current_node, "display") == null) 
     780            { 
     781                // well then create a format tag 
     782                Element display_tag = config.createElement("display"); 
     783                current_node = (Node) current_node.appendChild(display_tag); 
     784            } 
     785            else 
     786            { 
     787                current_node = GSXML.getChildByTagName(current_node, "display"); 
     788            } 
     789 
     790            if (GSXML.getChildByTagName(current_node, "format") == null) 
     791            { 
     792                // well then create a format tag 
     793                Element format_tag = config.createElement("format"); 
     794                current_node.appendChild(format_tag); 
     795            } 
     796 
     797            current_node.replaceChild(config.importNode(display_format, true), GSXML.getChildByTagName(current_node, "format")); 
     798 
     799            String new_config = this.converter.getString(config); 
     800 
     801            new_config = StringUtils.replace(new_config, "&lt;", "<"); 
     802            new_config = StringUtils.replace(new_config, "&gt;", ">"); 
     803            new_config = StringUtils.replace(new_config, "&quot;", "\""); 
     804 
     805            try 
     806            { 
     807                // Write to file (not original! for now) 
     808                BufferedWriter writer = new BufferedWriter(new FileWriter(collection_config + ".new")); 
     809                writer.write(new_config); 
     810                writer.close(); 
     811            } 
     812            catch (IOException e) 
     813            { 
     814                logger.error("IO Exception " + e); 
     815            } 
     816        } 
     817 
     818        if (subaction.equals("save")) 
     819        { 
     820            Element format_element = (Element) GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM); 
     821            Element format_statement = (Element) format_element.getFirstChild(); 
     822 
     823            try 
     824            { 
     825                // open collectionConfig.xml and read in to w3 Document 
     826                String collection_config = directory + "collectionConfig.xml"; 
     827                Document config = this.converter.getDOM(new File(collection_config), "UTF-8"); 
     828 
     829                //String tag_name = ""; 
     830                int k; 
     831                int index; 
     832                Element elem; 
     833                // Try importing entire tree to this.doc so we can add and remove children at ease 
     834                //Node current_node = this.doc.importNode(GSXML.getChildByTagName(config, "CollectionConfig"),true); 
     835                Node current_node = GSXML.getChildByTagName(config, "CollectionConfig"); 
     836                NodeList current_node_list; 
     837 
     838                if (service.equals("ClassifierBrowse")) 
     839                { 
     840                    //tag_name = "browse"; 
     841                    // if CLX then need to look in <classifier> X then <format> 
     842                    // default is <browse><format> 
     843 
     844                    current_node = GSXML.getChildByTagName(current_node, "browse"); 
     845 
     846                    // find CLX 
     847                    if (classifier != null) 
     848                    { 
     849                        current_node_list = GSXML.getChildrenByTagName(current_node, "classifier"); 
     850                        index = Integer.parseInt(classifier.substring(2)) - 1; 
     851 
     852                        // index should be given by X-1 
     853                        current_node = current_node_list.item(index); 
     854                        // what if classifier does not have a format tag? 
     855                        if (GSXML.getChildByTagName(current_node, "format") == null) 
     856                        { 
     857                            // well then create a format tag 
     858                            Element format_tag = config.createElement("format"); 
     859                            current_node.appendChild(format_tag); 
     860                        } 
     861                    } 
     862                    else 
     863                    { 
     864                        // To support all classifiers, set classifier to null?  There is the chance here that the format tag does not exist 
     865                        if (GSXML.getChildByTagName(current_node, "format") == null) 
     866                        { 
     867                            // well then create a format tag 
     868                            Element format_tag = config.createElement("format"); 
     869                            current_node.appendChild(format_tag); 
     870                        } 
     871                    } 
     872                } 
     873                else if (service.equals("AllClassifierBrowse")) 
     874                { 
     875                    current_node = GSXML.getChildByTagName(current_node, "browse"); 
     876                    if (GSXML.getChildByTagName(current_node, "format") == null) 
     877                    { 
     878                        // well then create a format tag 
     879                        Element format_tag = config.createElement("format"); 
     880                        current_node.appendChild(format_tag); 
     881                    } 
     882                } 
     883                else 
     884                { 
     885                    // look in <format> with no attributes 
     886                    current_node_list = GSXML.getChildrenByTagName(current_node, "search"); 
     887                    for (k = 0; k < current_node_list.getLength(); k++) 
     888                    { 
     889                        current_node = current_node_list.item(k); 
     890                        // if current_node has no attributes then break 
     891                        elem = (Element) current_node; 
     892                        if (elem.hasAttribute("name") == false) 
     893                            break; 
     894                    } 
     895                } 
     896 
     897                current_node.replaceChild(config.importNode(format_statement, true), GSXML.getChildByTagName(current_node, "format")); 
     898 
     899                // Now convert config document to string for writing to file 
     900                String new_config = this.converter.getString(config); 
     901 
     902                new_config = StringUtils.replace(new_config, "&lt;", "<"); 
     903                new_config = StringUtils.replace(new_config, "&gt;", ">"); 
     904                new_config = StringUtils.replace(new_config, "&quot;", "\""); 
     905 
     906                // Write to file (not original! for now) 
     907                BufferedWriter writer = new BufferedWriter(new FileWriter(collection_config + ".new")); 
     908                writer.write(new_config); 
     909                writer.close(); 
     910 
     911            } 
     912            catch (Exception ex) 
     913            { 
     914                logger.error("There was an exception " + ex); 
     915 
     916                StringWriter sw = new StringWriter(); 
     917                PrintWriter pw = new PrintWriter(sw, true); 
     918                ex.printStackTrace(pw); 
     919                pw.flush(); 
     920                sw.flush(); 
     921                logger.error(sw.toString()); 
     922            } 
     923 
     924        } 
     925 
     926        return response; 
     927    } 
    926928}