Changeset 32860 for gs3-extensions

Show
Ignore:
Timestamp:
05.03.2019 15:30:27 (6 months ago)
Author:
davidb
Message:

Mostly code tidy-up. In IIIFServerBridge.java, edit to remove hard-wired path

Location:
gs3-extensions/iiif-servlet/trunk/src/gsdl-src/java/org/greenstone/gsdl3
Files:
6 modified

Legend:

Unmodified
Added
Removed
  • gs3-extensions/iiif-servlet/trunk/src/gsdl-src/java/org/greenstone/gsdl3/IIIFServerBridge.java

    r32842 r32860  
    9191    public void init(String site_name) throws UnavailableException, Exception 
    9292    { 
    93         //org.greenstone.util.GlobalProperties.loadGlobalProperties(""); 
     93        ////GlobalProperties.loadGlobalProperties(config.getServletContext().getRealPath("")); 
     94             
     95        org.greenstone.util.GlobalProperties.loadGlobalProperties(""); 
    9496        //org.greenstone.util.GlobalProperties.loadGlobalProperties(config.getServletContext().getRealPath("")); 
    95         org.greenstone.util.GlobalProperties.loadGlobalProperties("/home/osboxes/research/code/greenstone3-svn/web"); 
     97        //org.greenstone.util.GlobalProperties.loadGlobalProperties("/home/osboxes/research/code/greenstone3-svn/web"); 
    9698        java.io.InputStream in = Class.forName("org.greenstone.util.GlobalProperties").getClassLoader().getResourceAsStream("global.properties"); 
    9799 
  • gs3-extensions/iiif-servlet/trunk/src/gsdl-src/java/org/greenstone/gsdl3/collection/IIIFCollection.java

    r32843 r32860  
    5555public class IIIFCollection extends Collection 
    5656{ 
    57  
    5857    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.collection.IIIFCollection.class.getName()); 
    5958 
    6059    /** does this collection provide the IIIF service */ 
    6160    protected boolean has_iiif = false; 
    62  
    63     /** earliest datestamp of an OAI collection. Also used to work out the earliest datetimestamp of the entire OAI repository */ 
    64     /* 
    65     protected long earliestOAIDatestamp = 0; 
    66     */ 
    6761     
    6862    /** a reference to the IIIFPMH service rack */ 
     
    116110    } 
    117111 
    118     // NOTE: 
    119     // Calling cleanUp() on IIIFPMH object iiif_service_rack will 
    120     // close any open dbs handles on module deactivation by 
    121     // MESSAGEROUTER (no deactivate yet called by 
    122     // IIIFMessageRouter) 
    123  
    124     // But the IIIFPMH object's cleanUp() is already called by 
    125     // superclass ServiceCluster, which goes around calling 
    126     // cleanUp() on all services/ServiceRacks. 
    127  
    128112    /** 
    129113     * whether this collection has IIIFPMH services 
     
    134118    } 
    135119 
    136     /** 
    137      * The earliesttimestamp entry in the oai-inf.db representing when the collection was created. 
    138      * Used by the OAIReceptionist 
    139     */ 
    140     /* 
    141     public long getEarliestOAIDatestamp() 
    142     { 
    143         return earliestOAIDatestamp; 
    144     } 
    145     */ 
    146120     
    147121  /** add any extra info for collection from IIIFConfig.xml */ 
     
    154128    protected boolean configureServiceRackList(Element service_rack_list, Element extra_info) 
    155129    { 
    156  
     130        //logger.info("*** Away to call getNamedElement() for service_rack_list = " + XMLConverter.getPrettyString(service_rack_list)); 
     131         
    157132      // find the IIIFPMH service 
    158133      Element iiif_service_xml = GSXML.getNamedElement(service_rack_list, GSXML.SERVICE_CLASS_ELEM, GSXML.NAME_ATT, "IIIFPMH"); 
     
    181156       
    182157      if (this.iiif_service_rack.configure(iiif_service_xml, extra_info)) { 
    183  
    184           /* 
    185           // once we've configured the IIIFPMH service, we can use the OAIPMH service to 
    186           // retrieve the earliest timestamp of this OAI collection from the oai-inf db 
    187           long earliestTimestamp = this.oai_service_rack.getEarliestTimestamp(); 
    188           if(earliestTimestamp == -1) { 
    189           this.earliestOAIDatestamp = -1; 
    190           logger.warn("No OAI timestamp for collection " + this.cluster_name); 
    191           } else { 
    192           this.earliestOAIDatestamp = earliestTimestamp; // milliseconds 
    193           } 
    194           */ 
    195          
     158     
    196159        // find out the supported service types for this service module 
    197160        Node types = this.iiif_service_rack.process(message); 
     
    224187      } 
    225188       
    226  
    227189      return false; 
    228190    } 
    229  
    230191} 
  • gs3-extensions/iiif-servlet/trunk/src/gsdl-src/java/org/greenstone/gsdl3/core/IIIFMessageRouter.java

    r32842 r32860  
    154154        Element e = doc.createElement(GSXML.COLLECTION_ELEM); 
    155155        e.setAttribute(GSXML.NAME_ATT, col_name); 
    156         /* 
    157         e.setAttribute(OAIXML.LASTMODIFIED, "" + c.getLastmodified()); 
    158         e.setAttribute(OAIXML.EARLIEST_DATESTAMP, "" + c.getEarliestDatestamp()); 
    159         e.setAttribute(OAIXML.EARLIEST_OAI_DATESTAMP, "" + c.getEarliestOAIDatestamp()); 
    160         */ 
     156 
    161157        this.collection_list.appendChild(e); 
    162158        return true; 
    163159         
    164160    } 
    165  
    166  
    167  
    168     //***************************************************************** 
    169     // auxiliary process methods 
    170     //***************************************************************** 
    171  
    172     /** 
    173      * handles requests made to the MessageRouter itself 
    174      *  
    175      * @param req 
    176      *            - the request Element- <request> 
    177      * @return the result Element - should be <response> 
    178      */ 
    179     /* 
    180   protected Element processMessage(Element req) { 
    181     Document doc = XMLConverter.newDOM(); 
    182     String type = req.getAttribute(GSXML.TYPE_ATT); 
    183     Element response = doc.createElement(GSXML.RESPONSE_ELEM); 
    184     response.setAttribute(GSXML.FROM_ATT, ""); 
    185      
    186     if (type.equals(OAIXML.OAI_SET_LIST)) 
    187       { 
    188     logger.info("oaiSetList request received"); 
    189     //this is the oai receptionist asking for a list of oai-support collections 
    190     response.setAttribute(GSXML.TYPE_ATT, OAIXML.OAI_SET_LIST); 
    191     response.appendChild(doc.importNode(this.collection_list, true)); 
    192     return response; 
    193       } 
    194     return super.processMessage(req); 
    195   } 
    196  
    197     */ 
    198161} 
  • gs3-extensions/iiif-servlet/trunk/src/gsdl-src/java/org/greenstone/gsdl3/core/IIIFReceptionist.java

    r32842 r32860  
    4545  /** Instead of a config_params object, only a site_name is needed by iiif receptionist. */ 
    4646  protected String site_name = null; 
    47   /** The unique  repository identifier */ 
    48     /* 
    49   protected String repository_id = null; 
    50     */ 
    5147     
    5248  /** the configure file of this receptionist passed from the iiif restlet. */ 
     
    5652  protected ModuleInterface mr = null; 
    5753   
    58   // Some of the data/responses will not change while the servlet is running, so 
    59   // we can cache them 
    60    
    61   /** A list of all the collections available to this IIIF image server */ 
    62   protected Element collection_list = null; 
    63   /** a vector of the names, for convenience */ 
    64   protected Vector<String> collection_name_list = null; 
    65   /** If this is true, then there are no OAI enabled collections, so can always return  
    66       noRecordsMatch (after validating the request params) */ 
    67   protected boolean noRecordsMatch = false; 
    68        
    69   /** A set of all known 'sets' */ 
    70   protected HashSet<String> set_set = null; 
    71  
    72   protected boolean has_super_colls = false; 
    73   /** a hash of super set-> collection list */ 
    74   protected HashMap<String, Vector<String>> super_coll_map = null; 
    75   /** store the super coll elements for convenience */ 
    76   HashMap<String, Element> super_coll_data = null; 
    77   /** store the metadata formats ??????*/ 
    78   /** The identify response */ 
    79   protected Element identify_response = null; 
    80   /** The list set response */ 
    81   protected Element listsets_response = null; 
    82   /** the list metadata formats response */ 
    83   protected Element listmetadataformats_response = null; 
    8454 
    8555  public IIIFReceptionist() { 
     
    9767    this.site_name = site_name; 
    9868  } 
     69 
    9970  /** sets the message router  - it should already be created and 
    10071   * configured in the init() of a servlet/restlet (IIIFServerBridge, for example) before being passed to the receptionist*/ 
     
    11586    } 
    11687    iiif_config = config; 
    117  
    118     /* 
    119     repository_id = getRepositoryIdentifier();  
    120     */ 
    121      
    122     /* 
    123     if (!configureSetInfo()) { 
    124       // there are no sets 
    125       logger.error("No sets (collections) available for IIIF"); 
    126       return false; 
    127     } 
    128     */ 
    12988     
    13089    return true; 
    13190  } 
    13291 
    133     /* 
    134   private boolean configureSetInfo() { 
    135     this.set_set = new HashSet<String>(); 
    136  
    137     // First, we get a list of all the OAI enabled collections 
    138     // We get this by sending a listSets request to the MR 
    139     Document doc = XMLConverter.newDOM(); 
    140     Element message = doc.createElement(GSXML.MESSAGE_ELEM); 
    141      
    142     Element request = GSXML.createBasicRequest(doc, OAIXML.OAI_SET_LIST, "", null); 
    143     message.appendChild(request); 
    144     Node msg_node = mr.process(message); 
    145      
    146     if (msg_node == null) { 
    147       logger.error("returned msg_node from mr is null"); 
    148       return false; 
    149     } 
    150     Element resp = (Element)GSXML.getChildByTagName(msg_node, GSXML.RESPONSE_ELEM); 
    151     Element coll_list = (Element)GSXML.getChildByTagName(resp, GSXML.COLLECTION_ELEM + GSXML.LIST_MODIFIER); 
    152     if (coll_list == null) { 
    153       logger.error("coll_list is null"); 
    154       return false; 
    155     } 
    156  
    157     this.collection_list = (Element)doc.importNode(coll_list, true); 
    158  
    159     // go through and store a list of collection names for convenience 
    160     // also create a 'to' attribute for the next request to the MR, which 
    161     // is a ListSets request to each collection 
    162     Node child = this.collection_list.getFirstChild(); 
    163     if (child == null) { 
    164       logger.error("collection list has no children"); 
    165       noRecordsMatch = true; 
    166       return false; 
    167     } 
    168      
    169     this.collection_name_list = new Vector<String>(); 
    170     StringBuffer to = new StringBuffer(); 
    171     boolean first = true; 
    172     while (child != null) { 
    173       if (child.getNodeName().equals(GSXML.COLLECTION_ELEM)) { 
    174     String coll_id =((Element) child).getAttribute(GSXML.NAME_ATT); 
    175     this.collection_name_list.add(coll_id); 
    176     if (!first) { 
    177       to.append(','); 
    178     } 
    179     first = false; 
    180     to.append(coll_id+"/"+OAIXML.LIST_SETS); 
    181       } 
    182       child = child.getNextSibling(); 
    183     } 
    184     if (first) { 
    185       // we haven't found any collections 
    186       logger.error("found no collection elements in collectionList"); 
    187       noRecordsMatch = true; 
    188       return false; 
    189     } 
    190     Document listsets_doc = XMLConverter.newDOM(); 
    191     Element listsets_element = listsets_doc.createElement(OAIXML.LIST_SETS); 
    192     this.listsets_response = getMessage(listsets_doc, listsets_element); 
    193      
    194     // Now, for each collection, get a list of all its sets 
    195     // might include subsets (classifiers) or super colls 
    196     // We'll reuse the first message, changing its type and to atts 
    197     request.setAttribute(GSXML.TYPE_ATT, ""); 
    198     request.setAttribute(GSXML.TO_ATT, to.toString()); 
    199     // send to MR 
    200     msg_node = mr.process(message); 
    201     //logger.info("*** " + XMLConverter.getPrettyString(msg_node)); 
    202     NodeList response_list =  ((Element)msg_node).getElementsByTagName(GSXML.RESPONSE_ELEM); 
    203     for (int c=0; c<response_list.getLength(); c++) { 
    204       // for each collection's response 
    205       Element response = (Element)response_list.item(c); 
    206       String coll_name = GSPath.getFirstLink(response.getAttribute(GSXML.FROM_ATT)); 
    207       logger.info("*** coll from response "+coll_name); 
    208       NodeList set_list = response.getElementsByTagName(OAIXML.SET); 
    209       for (int j=0; j<set_list.getLength(); j++) { 
    210     // now check if it a super collection 
    211     Element set = (Element)set_list.item(j); 
    212     String set_spec = GSXML.getNodeText((Element)GSXML.getChildByTagName(set, OAIXML.SET_SPEC)); 
    213     logger.info("*** set spec = "+set_spec); 
    214     // this may change if we add site name back in 
    215     // setSpecs will be collname or collname:subset or supercollname 
    216     if (set_spec.indexOf(":")==-1 && ! set_spec.equals(coll_name)) { 
    217       // it must be a super coll spec 
    218       logger.info("*** found super coll, "+set_spec); 
    219       // check that it is a valid one from config 
    220       if (this.has_super_colls == true && this.super_coll_data.containsKey(set_spec)) { 
    221         Vector <String> subcolls = this.super_coll_map.get(set_spec); 
    222         if (subcolls == null) { 
    223           logger.info("*** its new!!"); 
    224           // not in there yet 
    225           subcolls = new Vector<String>(); 
    226           this.set_set.add(set_spec); 
    227           this.super_coll_map.put(set_spec, subcolls); 
    228           // the first time a supercoll is mentioned, add into the set list 
    229           logger.info("*** finding the set info "+XMLConverter.getPrettyString(this.super_coll_data.get(set_spec))); 
    230           listsets_element.appendChild(GSXML.duplicateWithNewName(listsets_doc, this.super_coll_data.get(set_spec), OAIXML.SET, true)); 
    231         } 
    232         // add this collection to the list for the super coll 
    233         subcolls.add(coll_name); 
    234       } 
    235     } else { // its either the coll itself or a subcoll 
    236       // add in the set 
    237       listsets_element.appendChild(listsets_doc.importNode(set, true)); 
    238       this.set_set.add(set_spec); 
    239     } 
    240       } // for each set in the collection 
    241     } // for each OAI enabled collection 
    242     return true; 
    243   } 
    244     */ 
    24592     
    24693  protected void resetMessageRouter() { 
     
    311158    //The only thing that the oai receptionist can be sure is that these verbs are valid, nothing else. 
    312159    String verb = request.getAttribute(GSXML.TO_ATT); 
    313     /* 
    314     if (verb.equals(OAIXML.IDENTIFY)) { 
    315       return doIdentify(); 
    316       }*/ 
    317160     
    318161    if (verb.equals(OAIXML.GET_RECORD)) { 
     
    324167     
    325168  } 
    326  
    327     /* 
    328   private String getRepositoryIdentifier() { 
    329     Element ri = (Element)GSXML.getChildByTagName(iiif_config, OAIXML.REPOSITORY_IDENTIFIER); 
    330     if (ri != null) {  
    331       return GSXML.getNodeText(ri); 
    332     } 
    333     return ""; 
    334   } 
    335     */ 
    336  
    337   private void copyNamedElementfromConfig(Element to_elem, String element_name) { 
    338     Element original_element = (Element)GSXML.getChildByTagName(iiif_config, element_name); 
    339     if(original_element != null) { 
    340       GSXML.copyNode(to_elem, original_element); 
    341     } 
    342   } 
    343  
    344     /* 
    345   private Element doIdentify() { 
    346     //The validation for this verb has been done in OAIServer.validate(). So no bother here. 
    347     logger.info(""); 
    348     if (this.identify_response != null) { 
    349       // we have already created it 
    350       return getMessage(this.identify_response.getOwnerDocument(), this.identify_response); 
    351     } 
    352     Document doc = XMLConverter.newDOM(); 
    353     Element identify = doc.createElement(OAIXML.IDENTIFY); 
    354     //do the repository name 
    355     copyNamedElementfromConfig(identify, OAIXML.REPOSITORY_NAME); 
    356     //do the baseurl 
    357     copyNamedElementfromConfig(identify, OAIXML.BASE_URL); 
    358     //do the protocol version 
    359     copyNamedElementfromConfig(identify, OAIXML.PROTOCOL_VERSION); 
    360          
    361     //There can be more than one admin email according to the OAI specification 
    362     NodeList admin_emails = GSXML.getChildrenByTagName(iiif_config, OAIXML.ADMIN_EMAIL); 
    363     int num_admin = 0; 
    364     Element from_admin_email = null;   
    365     if (admin_emails != null) { 
    366       num_admin = admin_emails.getLength(); 
    367     } 
    368     for (int i=0; i<num_admin; i++) { 
    369       GSXML.copyNode(identify, admin_emails.item(i)); 
    370     } 
    371  
    372     // IIIF does not have the equivalent of oai earliestDatestamp  
    373       
    374     // output the oai identifier 
    375     Element description = doc.createElement(OAIXML.DESCRIPTION); 
    376     identify.appendChild(description); 
    377     // TODO, make this a valid id 
    378     Element oaiIdentifier = OAIXML.createOAIIdentifierXML(doc, repository_id, "lucene-jdbm-demo", "ec159e"); 
    379     description.appendChild(oaiIdentifier); 
    380  
    381     // if there are any oaiInfo metadata, add them in too. 
    382     Element info = (Element)GSXML.getChildByTagName(iiif_config, OAIXML.OAI_INFO); 
    383     if (info != null) { 
    384       NodeList meta = GSXML.getChildrenByTagName(info, OAIXML.METADATA); 
    385       if (meta != null && meta.getLength() > 0) { 
    386     Element gsdl = OAIXML.createGSDLElement(doc); 
    387     description.appendChild(gsdl); 
    388     for (int m = 0; m<meta.getLength(); m++) { 
    389       GSXML.copyNode(gsdl, meta.item(m)); 
    390     } 
    391      
    392       } 
    393     } 
    394     this.identify_response = identify; 
    395     return getMessage(doc, identify); 
    396   } 
    397     */ 
    398169     
    399170  private Element doGetRecord(Element req){ 
    400     logger.info(""); 
    401     /** arguments: 
    402         identifier: required 
    403         metadataPrefix: required 
    404     *  Exceptions: badArgument; cannotDisseminateFormat; idDoesNotExist 
    405     */  
     171    logger.info("");  
     172 
    406173    Document doc = XMLConverter.newDOM(); 
    407174    Element get_record = doc.createElement(IIIFXML.GET_RECORD); 
     
    424191      return OAIXML.createErrorMessage(OAIXML.ID_DOES_NOT_EXIST, ""); 
    425192    }     
    426     //String name_of_site = strs[0]; 
    427193    String coll_name = strs[0]; 
    428194    String oid = strs[1]; 
     
    445211    return GSXML.nodeToElement(result_node); 
    446212  } 
    447  
    448  
    449213} 
    450214 
  • gs3-extensions/iiif-servlet/trunk/src/gsdl-src/java/org/greenstone/gsdl3/service/IIIFPMH.java

    r32842 r32860  
    6161   
    6262  protected SimpleCollectionDatabase coll_db = null; 
    63     //protected SimpleCollectionDatabase oaiinf_db = null; 
    6463   
    6564  protected String site_name = ""; 
     
    7978  /** constructor */ 
    8079  public IIIFPMH() { 
    81  
    8280  } 
    8381   
     
    8987    this.coll_db = null; 
    9088    } 
    91     /* 
    92     if (this.oaiinf_db != null){ 
    93         this.oaiinf_db.closeDatabase(); 
    94     }*/ 
    9589  } 
    9690   
     
    115109    Element metadata_list = (Element) GSXML.getChildByTagName(extra_info, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER); 
    116110 
     111    // Is indexStem needed for IIIF // **** 
    117112    if (metadata_list != null) { 
    118        
     113     
    119114      Element index_stem_elem = (Element) GSXML.getNamedElement(metadata_list, GSXML.METADATA_ELEM, GSXML.NAME_ATT, "indexStem"); 
    120115       
     
    137132    } 
    138133 
    139     /* 
    140     // Work out what sets this collection has. 
    141     // 
    142     // Will usually contain the collection itself, optional super 
    143     // collection, and maybe subcolls if appropriate classifiers are 
    144     // present. 
    145      
    146     configureSetInfo();*/ 
    147      
    148     // the short_service_info is used by the message router to find the method names,  
    149     /* 
    150     Element list_records = this.desc_doc.createElement(GSXML.SERVICE_ELEM); 
    151     list_records.setAttribute(GSXML.NAME_ATT, OAIXML.LIST_RECORDS); 
    152     list_records.setAttribute(GSXML.TYPE_ATT, "oai"); 
    153     this.short_service_info.appendChild(list_records); 
    154  
    155     Element list_identifiers = this.desc_doc.createElement(GSXML.SERVICE_ELEM); 
    156     list_identifiers.setAttribute(GSXML.NAME_ATT, OAIXML.LIST_IDENTIFIERS); 
    157     list_identifiers.setAttribute(GSXML.TYPE_ATT, "oai"); 
    158     this.short_service_info.appendChild(list_identifiers); 
    159      
    160     Element list_sets = this.desc_doc.createElement(GSXML.SERVICE_ELEM); 
    161     list_sets.setAttribute(GSXML.NAME_ATT, OAIXML.LIST_SETS); 
    162     list_sets.setAttribute(GSXML.TYPE_ATT, "oai"); 
    163     this.short_service_info.appendChild(list_sets); 
    164      
    165     Element list_metadata_formats = this.desc_doc.createElement(GSXML.SERVICE_ELEM); 
    166     list_metadata_formats.setAttribute(GSXML.NAME_ATT, OAIXML.LIST_METADATA_FORMATS); 
    167     list_metadata_formats.setAttribute(GSXML.TYPE_ATT, "oai"); 
    168     this.short_service_info.appendChild(list_metadata_formats); 
    169     */ 
    170134    Element get_record = this.desc_doc.createElement(GSXML.SERVICE_ELEM); 
    171135    get_record.setAttribute(GSXML.NAME_ATT, IIIFXML.GET_RECORD); 
     
    177141 
    178142  public boolean configureIIIF(Element iiif_config_elem) { 
    179       /*       
    180     this.meta_formats_definition = this.desc_doc.createElement(OAIXML.LIST_METADATA_FORMATS); 
    181     this.format_response_map = new HashMap<String, Element>(); 
    182     this.format_elements_map = new HashMap<String, HashSet<String>>(); 
    183     this.format_meta_elem_map = new HashMap<String, Element>(); 
    184  
    185     // for now, all we want is the metadata prefix description and the mapping list 
    186     Element main_lmf_elem = (Element) GSXML.getChildByTagName(oai_config_elem, OAIXML.LIST_METADATA_FORMATS); 
    187     if (main_lmf_elem == null) { 
    188       logger.error("No listMetadataFormats element found in OAIConfig.xml"); 
    189       return false; 
    190     } 
    191     NodeList meta_formats_list = this.config_info.getElementsByTagName(OAIXML.METADATA_FORMAT); 
    192     if (meta_formats_list.getLength() == 0) { 
    193       logger.error("no metadataFormat elements found in OAIPMH serviceRack element"); 
    194       return false; 
    195     } 
    196143       
    197     boolean found_meta_format = false; 
    198     for(int i=0; i<meta_formats_list.getLength(); i++) { 
    199       Element mf = (Element) meta_formats_list.item(i); 
    200       String prefix = mf.getAttribute(OAIXML.METADATA_PREFIX); 
    201       if (prefix.equals("")) { 
    202     logger.error("metadataFormat element had no metadataPrefix attribute"); 
    203     continue; 
    204       } 
    205       // get the right format from OAICOnfig 
    206       Element meta_format = findNamedMetadataFormat(main_lmf_elem, prefix); 
    207       if (meta_format == null) { 
    208     logger.error("Couldn't find metadataFormat named "+prefix+" in OAIConfig.xml"); 
    209     continue; 
    210       } 
    211        
    212       // copy the format definition into our stored Element 
    213       Element collection_version_format = (Element) this.desc_doc.importNode(meta_format, true); 
    214       collection_version_format.setAttribute(GSXML.NAME_ATT, prefix); // for convenience 
    215       this.meta_formats_definition.appendChild(collection_version_format); 
    216       // set up the response element for this format 
    217       format_response_map.put(prefix, OAIXML.getMetadataFormatShort(this.desc_doc, collection_version_format)); 
    218       // add in collection specific mappings 
    219       addCollectionMappings(collection_version_format, mf); 
    220       // now set up a list of all collection elements for reverse lookup of the mapping 
    221       format_elements_map.put(prefix, getAllCollectionElements(collection_version_format)); 
    222       format_meta_elem_map.put(prefix, OAIXML.getMetadataPrefixElement(this.desc_doc, prefix, collection_version_format)); 
    223        
    224     } // end for 
    225       */ 
    226        
    227     // Open the coll db db databases and store handles to them   
     144      // Open the coll db db databases and store handles to them     
    228145    coll_db = new SimpleCollectionDatabase(infodb_type); 
    229146    if (!coll_db.databaseOK()) { 
     
    231148      return false; 
    232149    } 
    233     /* 
    234     oaiinf_db = new SimpleCollectionDatabase(infodb_type); 
    235     if (!oaiinf_db.databaseOK()) { 
    236       logger.error("Couldn't create the oai-inf database of type "+infodb_type); 
    237       return false; 
    238     } 
    239     */ 
    240150     
    241151    // Open databases for querying 
     
    245155      return false; 
    246156    } 
    247     /* 
    248     // the oaiinf_db is called oai-inf.<infodb_type_extension> 
    249     String oaiinf_db_file = GSFile.OAIInfoDatabaseFile(this.site_home, this.cluster_name, "oai-inf", infodb_type); 
    250     File oaiinfFile = new File(oaiinf_db_file); 
    251      
    252     if(!oaiinfFile.exists()) { 
    253     logger.warn("oai-inf database for collection + " + this.cluster_name + " does not exist."); 
    254     oaiinf_db = null; 
    255     } else if (!this.oaiinf_db.openDatabase(oaiinf_db_file, SimpleCollectionDatabase.READ)) { 
    256     logger.warn("Could not open oai-inf database for collection + " + this.cluster_name + "!"); 
    257     oaiinf_db = null; 
    258     } 
    259     */ 
    260157     
    261158    return true; 
    262159  } 
    263160 
    264     /** 
    265      * @return the associated OAICollection's OAI_EARLIEST_TIMESTAMP_OID record's  
    266      * OAI_INF_TIMESTAMP field from the collection's oai-inf.db IN MILLISECONDS 
    267      */ 
    268     /* 
    269     public long getEarliestTimestamp() { 
    270     long timestamp = -1; 
    271      
    272     DBInfo oai_info = null; 
    273     if(oaiinf_db != null) { 
    274         // get internal record containing the earliest timestamp of the collection 
    275         oai_info = this.oaiinf_db.getInfo(OAIXML.OAI_EARLIEST_TIMESTAMP_OID); 
    276         if (oai_info == null) { 
    277         logger.warn("Can't get collection " + this.cluster_name + "'s earliest timestamp from oai-inf db. No entry for 'OID' " + OAIXML.OAI_EARLIEST_TIMESTAMP_OID + " in the db.");         
    278         } else { 
    279         timestamp = Long.parseLong(oai_info.getInfo(OAIXML.OAI_INF_TIMESTAMP)) * 1000; // stored in seconds, so x1000 to  convert to milliseconds 
    280         //logger.info("@@@ found earliest OAI timestamp for collection " + this.coll_name + ": " + timestamp + " (ms)"); 
    281         } 
    282     } 
    283     return timestamp; 
    284     } 
    285     */ 
    286  
    287     /* 
    288   protected Element findNamedMetadataFormat(Element list_meta_formats, String prefix) { 
    289     NodeList formats = list_meta_formats.getElementsByTagName(OAIXML.METADATA_FORMAT); 
    290     for (int i=0; i<formats.getLength(); i++) { 
    291       Element format = (Element)formats.item(i); 
    292       String meta_name = GSXML.getNodeText((Element)GSXML.getChildByTagName(format, OAIXML.METADATA_PREFIX)); 
    293       if (prefix.equals(meta_name)) { 
    294     return format; 
    295       } 
    296     } 
    297     return null; 
    298   } 
    299     */ 
    300      
    301     /** goes through the mappings from the collection one, and replaces existing ones in the main one */ 
    302     /* 
    303     protected void addCollectionMappings(Element main_meta_format, Element coll_meta_format) { 
    304  
    305       Element element_list = (Element)GSXML.getChildByTagName(main_meta_format, OAIXML.ELEMENT+GSXML.LIST_MODIFIER); 
    306       Document doc = element_list.getOwnerDocument(); 
    307       NodeList coll_elements = coll_meta_format.getElementsByTagName(OAIXML.ELEMENT); 
    308       if (coll_elements.getLength()==0) { 
    309     // no mappings to include 
    310     return; 
    311       } 
    312       for (int i=0; i<coll_elements.getLength(); i++) { 
    313     Element e = (Element)coll_elements.item(i); 
    314     String elem_name = e.getAttribute(GSXML.NAME_ATT); 
    315     Element main_elem = GSXML.getNamedElement(element_list, OAIXML.ELEMENT, GSXML.NAME_ATT, elem_name); 
    316     if (main_elem == null) { 
    317       logger.error(elem_name+" not found in meta format, not using it"); 
    318     } else { 
    319       element_list.replaceChild(doc.importNode(e, true),main_elem ); 
    320       } 
    321       } 
    322     } 
    323     */ 
    324      
    325     /** goes through all the mappings and makes a set of all collection 
    326     metadata names that could become an oai meta element - acts as 
    327     a reverse lookup for the mappings */ 
    328     /* 
    329     protected HashSet<String> getAllCollectionElements(Element meta_format) { 
    330       HashSet<String> meta_name_set = new HashSet<String>(); 
    331       NodeList elements = meta_format.getElementsByTagName(OAIXML.ELEMENT); 
    332       for (int i=0; i<elements.getLength(); i++) { 
    333     Element e = (Element)elements.item(i); 
    334     Element map = (Element)GSXML.getChildByTagName(e, OAIXML.MAPPING); 
    335     if (map == null) { 
    336       // there is no mapping, just use the element name 
    337       meta_name_set.add(e.getAttribute(GSXML.NAME_ATT)); 
    338     } else { 
    339       String list_of_names = map.getAttribute(OAIXML.ELEMENTS); 
    340       String[] name_array = list_of_names.split(","); 
    341       for (int j=0; j<name_array.length; j++) { 
    342         meta_name_set.add(name_array[j]); 
    343       } 
    344     } 
    345       } 
    346       return meta_name_set; 
    347     } 
    348     */ 
    349      
    350161  /** returns a specific service description */ 
    351162  public Element getServiceDescription(Document doc, String service_id, String lang, String subset) { 
    352  
    353       /* 
    354     if (service_id.equals(OAIXML.LIST_RECORDS)) { 
    355       Element list_records = doc.createElement(GSXML.SERVICE_ELEM); 
    356       list_records.setAttribute(GSXML.NAME_ATT, OAIXML.LIST_RECORDS); 
    357       list_records.setAttribute(GSXML.TYPE_ATT, "oai"); 
    358       return list_records; 
    359     } 
    360      
    361     if (service_id.equals(OAIXML.LIST_IDENTIFIERS)) { 
    362       Element list_identifiers = doc.createElement(GSXML.SERVICE_ELEM); 
    363       list_identifiers.setAttribute(GSXML.NAME_ATT, OAIXML.LIST_IDENTIFIERS); 
    364       list_identifiers.setAttribute(GSXML.TYPE_ATT, "oai"); 
    365       return list_identifiers; 
    366     } 
    367     if (service_id.equals(OAIXML.LIST_SETS)) { 
    368       Element list_sets = doc.createElement(GSXML.SERVICE_ELEM); 
    369       list_sets.setAttribute(GSXML.NAME_ATT, OAIXML.LIST_SETS); 
    370       list_sets.setAttribute(GSXML.TYPE_ATT, "oai"); 
    371       return list_sets; 
    372     } 
    373     if (service_id.equals(OAIXML.LIST_METADATA_FORMATS)) { 
    374       Element list_metadata_formats = doc.createElement(GSXML.SERVICE_ELEM); 
    375       list_metadata_formats.setAttribute(GSXML.NAME_ATT, OAIXML.LIST_METADATA_FORMATS); 
    376       list_metadata_formats.setAttribute(GSXML.TYPE_ATT, "oai"); 
    377       return list_metadata_formats; 
    378     } 
    379       */ 
    380163       
    381164    if (service_id.equals(IIIFXML.GET_RECORD)) { 
     
    388171    return null; 
    389172  } 
    390  
    391   /** The list sets service returns all the sets that this collection is/is part of/contains. This is gathered by Receptionist from all collections to answer the OAI ListSets request.  */ 
    392     /* 
    393   protected Element processListSets(Element req) { 
    394     return list_sets_response; 
    395   } 
    396     */ 
    397173     
    398174  /** returns the actual record element used in the OAI GetRecord response */ 
     
    422198     
    423199    String oid = param_map.get(IIIFXML.OID); // TODO should this be identifier??? 
    424  
    425     /* 
    426     boolean OID_is_deleted = false; 
    427     long millis = -1; 
    428  
    429     DBInfo oai_info = null; 
    430     if(oaiinf_db != null) { 
    431     oai_info = this.oaiinf_db.getInfo(oid); 
    432     if (oai_info == null) { 
    433         logger.warn("OID: " + oid + " is not present in the collection's oai-inf database."); 
    434     } else  { 
    435  
    436         // indexdb doesn't have info on deleted docs, only oaiinf db does. 
    437         // So only oaiinfdb has timestamps for deleted docs 
    438         // For non-deleted doc ids: also obtain timestamp from oaiinf db,  
    439         // but if the oaiinf db doesn't exist, resort to oailastmodified fields of indexdb. 
    440         String timestamp = oai_info.getInfo(OAIXML.OAI_INF_TIMESTAMP); // stored in seconds, like oailastmodified in the collection index db 
    441         millis = Long.parseLong(timestamp)*1000; // in milliseconds      
    442          
    443         String oaiinf_status = oai_info.getInfo(OAIXML.OAI_INF_STATUS); 
    444         if(oaiinf_status != null && oaiinf_status.equals(OAIXML.OAI_INF_DELETED)) { 
    445         OID_is_deleted = true; 
    446         } 
    447     } 
    448     } 
    449     */ 
    450200     
    451201    //get a DBInfo object of the identifier; if this identifier is not present in the database, 
     
    459209    } 
    460210 
    461     /* 
    462     else if (millis == -1) { // so couldn't get doc lastmod from oaiinf db, get oailastmodified from collection's index db 
    463     millis = getDateStampMillis(info);   
    464     } 
    465     String oailastmodified = (millis == -1) ? "" : OAIXML.getTime(millis); 
    466     */ 
    467  
     211 
     212    // **** 
    468213    Element get_record_response = doc.createElement(GSXML.RESPONSE_ELEM); 
    469214    Element get_record = doc.createElement(IIIFXML.GET_RECORD); 
     
    472217    //compose the header element 
    473218    record.appendChild(createHeaderElement(doc, oid));       
    474     //if(!OID_is_deleted) { // **** 
    475     //compose the metadata element 
    476     record.appendChild(createMetadataElement(doc, prefix, info)); 
    477     // } // **** 
     219    //compose the metadata element 
     220    record.appendChild(createMetadataElement(doc, prefix, info)); 
    478221    get_record.appendChild(record); 
    479222    return get_record_response; 
    480223  } 
    481224 
    482   /** return a list of records in specified set, containing metadata from specified prefix*/ 
    483     /* 
    484   protected Element processListRecords(Element req) { 
    485     return processListIdentifiersOrRecords(req, OAIXML.LIST_RECORDS, true); 
    486   } 
    487     */ 
    488   /** return a list of identifiers in specified set that contain metadata belonging to specified prefix. */ 
    489     /* 
    490   protected Element processListIdentifiers(Element req) { 
    491     return processListIdentifiersOrRecords(req, OAIXML.LIST_IDENTIFIERS, false); 
    492   } 
    493     */ 
    494      
    495   // Get a list of records/identifiers that match the parameters. 
    496      
    497   //protected Element processListIdentifiersOrRecords(Element req, String response_name, boolean include_metadata) { 
    498     /** arguments: 
    499         metadataPrefix: required 
    500      *  from: optional 
    501      *  until: optional 
    502      *  set: optional 
    503      *  resumptionToken: exclusive and optional (ignored as it has been handled by OAIReceptionist) 
    504      *  Exceptions: badArgument; cannotDisseminateFormat; idDoesNotExist 
    505      */ 
    506     /* 
    507     NodeList params = GSXML.getChildrenByTagName(req, GSXML.PARAM_ELEM); 
    508      
    509     if(params.getLength() == 0) { 
    510       logger.error("must at least have the metadataPrefix parameter, can't be none"); 
    511       return OAIXML.createErrorResponse(OAIXML.BAD_ARGUMENT, ""); 
    512     } 
    513      
    514     HashMap<String, String> param_map = GSXML.getParamMap(params);   
    515      
    516     String prefix = ""; 
    517     Date from_date = null; 
    518     Date until_date = null; 
    519      
    520     if(param_map.containsKey(OAIXML.METADATA_PREFIX) == false) {     
    521       //Just a double-check 
    522       logger.error("A param element containing the metadataPrefix is not present."); 
    523       return OAIXML.createErrorResponse(OAIXML.CANNOT_DISSEMINATE_FORMAT, ""); 
    524     } 
    525     prefix = param_map.get(OAIXML.METADATA_PREFIX); 
    526     if (prefix == null || prefix.equals("")) { 
    527       //Just a double-check 
    528       logger.error("the value of metadataPrefix att is not present in the request."); 
    529       return OAIXML.createErrorResponse(OAIXML.CANNOT_DISSEMINATE_FORMAT, ""); 
    530     } 
    531      
    532     if(param_map.containsKey(OAIXML.FROM)) { 
    533       String from = param_map.get(OAIXML.FROM); 
    534       from_date = OAIXML.getDate(from); 
    535     }     
    536     if(param_map.containsKey(OAIXML.UNTIL)) { 
    537       String until = param_map.get(OAIXML.UNTIL); 
    538       until_date = OAIXML.getDate(until); 
    539     }     
    540  
    541     if (!format_response_map.containsKey(prefix)) { 
    542       logger.error(prefix + " metadata prefix is not supported for collection "+this.coll_name); 
    543       return OAIXML.createErrorResponse(OAIXML.CANNOT_DISSEMINATE_FORMAT, ""); 
    544     } 
    545  
    546     // get list of oids 
    547     ArrayList<String> oid_list = null; 
    548     if(oaiinf_db != null) { // try getting the OIDs from the oaiinf_db 
    549     oid_list = new ArrayList<String>(oaiinf_db.getAllKeys()); 
    550      
    551     if(oid_list == null) { // try getting the OIDs from the oai entries in the index db 
    552         logger.warn("@@@@@@@@@@@@@ NO OIDs in oai-inf db for " + this.cluster_name); 
    553         oid_list = getChildrenIds(OAIXML.BROWSELIST); 
    554     } 
    555     } 
    556  
    557     if (oid_list == null) { 
    558       logger.error("No matched records found in collection: oai-inf and index db's browselist are empty"); 
    559       return OAIXML.createErrorResponse(OAIXML.NO_RECORDS_MATCH, ""); 
    560     } 
    561     // all validation is done 
    562  
    563     // get the list of elements that are in this metadata prefix 
    564     HashSet<String> set_of_elems = format_elements_map.get(prefix); 
    565  
    566     Document doc = XMLConverter.newDOM(); 
    567     Element list_items_response = doc.createElement(GSXML.RESPONSE_ELEM); 
    568     Element list_items = doc.createElement(response_name); 
    569     list_items_response.appendChild(list_items); 
    570  
    571     for(int i=0; i<oid_list.size(); i++) { 
    572       String oid = oid_list.get(i); 
    573  
    574       if(oid.equals(OAIXML.OAI_EARLIEST_TIMESTAMP_OID)) { // internal id not doc id, so skip 
    575       continue; 
    576       } 
    577        
    578       boolean OID_is_deleted = false; 
    579       long millis = -1; 
    580  
    581       DBInfo oai_info = null; 
    582       if(oaiinf_db != null) { 
    583       oai_info = this.oaiinf_db.getInfo(oid); 
    584       if (oai_info == null) { 
    585           logger.warn("OID: " + oid + " is not present in the collection's oai-inf database."); 
    586       } else  { 
    587            
    588           // indexdb doesn't have info on deleted docs, only oaiinf db does. 
    589           // So only oaiinfdb has timestamps for deleted docs 
    590           // For non-deleted doc ids: also obtain timestamp from oaiinf db,  
    591           // but if the oaiinf db doesn't exist, resort to oailastmodified fields of indexdb. 
    592           String timestamp = oai_info.getInfo(OAIXML.OAI_INF_TIMESTAMP); // stored in seconds like oailastmodified in the collection index db          
    593           millis = Long.parseLong(timestamp)*1000; // in milliseconds 
    594            
    595           String oaiinf_status = oai_info.getInfo(OAIXML.OAI_INF_STATUS); 
    596           if(oaiinf_status != null && oaiinf_status.equals(OAIXML.OAI_INF_DELETED)) { 
    597           OID_is_deleted = true; 
    598           } 
    599       } 
    600       } 
    601       DBInfo info = this.coll_db.getInfo(oid); 
    602       if (info == null) { // can happen if oid was deleted, in which case only oai_info keeps a record of the oid 
    603       if(!OID_is_deleted) { // we don't expect to find entries for deleted docs in index db. 
    604           logger.error("Collection database does not contain information about oid: " +oid); 
    605       } 
    606       } 
    607       else if (millis == -1) { // so couldn't get doc lastmod from oaiinf db, get oailastmodified from collection's index db 
    608        
    609       millis = getDateStampMillis(info); 
    610       } 
    611  
    612       Date this_date = null; 
    613       String oailastmodified = (millis == -1) ? "" : OAIXML.getTime(millis); 
    614        
    615       if (millis == -1) { 
    616       if (from_date != null || until_date !=null) { 
    617           continue; // if this doc doesn't have a date for some reason, and 
    618           // we are doing a date range, then don't include it. 
    619       } 
    620       } else { 
    621       this_date = new Date(millis); 
    622       if (from_date != null) { 
    623           if(this_date.before(from_date)) { 
    624           continue; 
    625           } 
    626       } 
    627       if (until_date != null) { 
    628           if (this_date.after(until_date)) { 
    629           continue; 
    630           } 
    631       }     
    632       } 
    633        
    634       //compose the header element, which we'll be appending no matter what 
    635       Element header = createHeaderElement(doc, oid, oailastmodified, OID_is_deleted); 
    636  
    637       if (include_metadata) { // doing ListRecords 
    638       // compose a record for adding header and metadata 
    639       Element record = doc.createElement(OAIXML.RECORD); 
    640       list_items.appendChild(record); 
    641       //insert the header element 
    642       record.appendChild(header); 
    643       //Now check that this id has metadata for the required prefix. 
    644       if (info != null && documentContainsMetadata(info, set_of_elems)) { 
    645           // YES, it does have some metadata for this prefix         
    646           //compose the metadata element 
    647           record.appendChild(createMetadataElement(doc, prefix, info)); 
    648       } // otherwise the oid was 'deleted' and only in the oai-inf db and not in the info (collection index) db 
    649       } else { // doing ListIdentifiers 
    650       //append the header element 
    651       list_items.appendChild(header);       
    652       }       
    653        
    654     }//end of for(int i=0; i<oid_list.size(); i++) of doing thru each record 
    655      
    656     return list_items_response;         
    657      
    658   } 
    659 */ 
    660    
    661   // have implemented setDescription as an element, instead of a container containing metadata 
    662 /* 
    663   private boolean configureSetInfo() { 
    664  
    665     Document doc = XMLConverter.newDOM(); 
    666     this.list_sets_response = doc.createElement(GSXML.RESPONSE_ELEM); 
    667     Element list_sets_elem = doc.createElement(OAIXML.LIST_SETS); 
    668     this.list_sets_response.appendChild(list_sets_elem); 
    669     String set_name = this.coll_name; 
    670     String set_description = null; 
    671     Element name_elem = (Element)GSXML.getChildByTagName(this.config_info, OAIXML.SET_NAME); 
    672     if (name_elem!=null) { 
    673       set_name = GSXML.getNodeText(name_elem); 
    674       if (set_name.equals("")) { 
    675     set_name = this.coll_name; // default to coll name if can't find one 
    676       } 
    677     } 
    678     Element description_elem = (Element)GSXML.getChildByTagName(this.config_info, OAIXML.SET_DESCRIPTION); 
    679     if (description_elem!=null) { 
    680       set_description = GSXML.getNodeText(description_elem); 
    681       if (set_description.equals("")) { 
    682     set_description = null; 
    683       } 
    684     } 
    685     Element coll_set = OAIXML.createSet(doc, this.coll_name, set_name, set_description); 
    686     list_sets_elem.appendChild(coll_set); 
    687      
    688     // are we part of any super sets? 
    689     NodeList super_set_list = GSXML.getChildrenByTagName(this.config_info, OAIXML.OAI_SUPER_SET); 
    690     for (int i=0; i<super_set_list.getLength(); i++) { 
    691       String super_name = ((Element)super_set_list.item(i)).getAttribute(GSXML.NAME_ATT); 
    692       if (super_name != null && !super_name.equals("")) { 
    693     list_sets_elem.appendChild(OAIXML.createSet(doc, super_name, super_name, null)); 
    694       } 
    695     } 
    696     return true; 
    697   } 
    698 */ 
    699225     
    700226 /** create the metadata element used when processing ListRecords/GetRecord requests 
     
    804330        Element header = doc.createElement(OAIXML.HEADER); 
    805331     
    806     // if deleted, get the date and change oailastmodified to timestamp in oaiinfo 
    807     /* 
    808     if(deleted) { 
    809         header.setAttribute(OAIXML.OAI_INF_STATUS, OAIXML.HEADER_STATUS_ATTR_DELETED); // set the header status to deleted 
    810         // then the timestamp for deletion will be from oai-inf database  
    811     } 
    812     */ 
    813332        Element identifier = doc.createElement(IIIFXML.IDENTIFIER); 
    814333    GSXML.setNodeText(identifier, coll_name + ":" + oid); 
    815334        header.appendChild(identifier); 
    816     /* 
    817         Element set_spec = doc.createElement(OAIXML.SET_SPEC); 
    818     GSXML.setNodeText(set_spec, coll_name); 
    819         header.appendChild(set_spec); 
    820         Element datestamp = doc.createElement(OAIXML.DATESTAMP); 
    821         GSXML.setNodeText(datestamp, oailastmodified); 
    822         header.appendChild(datestamp); 
    823     */ 
     335 
    824336        return header; 
    825337  } 
    826338 
    827      
    828   /** return the metadata information  */ 
    829 /* 
    830   protected Element processListMetadataFormats(Element req) { 
    831     // the request sent here must contain an OID. see doListMetadataFormats() in OAIReceptionist 
    832     Element param = GSXML.getNamedElement(req, GSXML.PARAM_ELEM, GSXML.NAME_ATT, OAIXML.OID); 
    833     if (param == null) { 
    834       logger.error("An element containing the OID attribute not is present."); 
    835       return OAIXML.createErrorResponse(OAIXML.ID_DOES_NOT_EXIST, ""); 
    836     } 
    837     String oid = param.getAttribute(GSXML.VALUE_ATT); 
    838     if (oid == null || oid.equals("")) { 
    839       logger.error("No OID is present in the request."); 
    840       return OAIXML.createErrorResponse(OAIXML.ID_DOES_NOT_EXIST, ""); 
    841     } 
    842 */ 
    843     /* 
    844     ArrayList<String> oid_list = null; 
    845     if(oaiinf_db != null) { // try getting the OIDs from the oaiinf_db 
    846     oid_list = new ArrayList<String>(oaiinf_db.getAllKeys()); 
    847      
    848     if(oid_list == null) { // try getting the OIDs from the oai entries in the index db 
    849         oid_list = getChildrenIds(OAIXML.BROWSELIST); 
    850     } 
    851     } 
    852     */ 
    853 /* 
    854     // assume meta formats are only for OIDs that have not been deleted 
    855     // so don't need to check oai-inf db, and can just check collection's index db for list of OIDs 
    856     ArrayList<String> oid_list = getChildrenIds(OAIXML.BROWSELIST); 
    857     if (oid_list == null || oid_list.contains(oid) == false) { 
    858       logger.error("OID: " + oid + " is not present in the database."); 
    859       Element e= OAIXML.createErrorResponse(OAIXML.ID_DOES_NOT_EXIST, ""); 
    860 //      logger.error((new XMLConverter()).getPrettyString (e)); 
    861       return e; 
    862     } 
    863      
    864     DBInfo info = null;     
    865     info = this.coll_db.getInfo(oid); 
    866     if (info == null) { //just double check 
    867       return OAIXML.createErrorResponse(OAIXML.OAI_SERVICE_UNAVAILABLE, ""); 
    868     } 
    869      
    870     Document doc = XMLConverter.newDOM(); 
    871     Element list_metadata_formats_response = doc.createElement(GSXML.RESPONSE_ELEM); 
    872      
    873     Element list_metadata_formats = doc.createElement(OAIXML.LIST_METADATA_FORMATS); 
    874     list_metadata_formats_response.appendChild(list_metadata_formats); 
    875     boolean has_meta_format = false; 
    876      
    877     // for each format in format_elements_map 
    878     Iterator<String> it = format_elements_map.keySet().iterator(); 
    879     while (it.hasNext()) { 
    880       String format = it.next(); 
    881       HashSet<String> set_of_elems = format_elements_map.get(format); 
    882       if (documentContainsMetadata(info, set_of_elems)) { 
    883     // add this format into the response 
    884     has_meta_format = true; 
    885     list_metadata_formats.appendChild(doc.importNode(format_response_map.get(format), true)); 
    886       } 
    887     } 
    888  
    889     if (has_meta_format == false) { 
    890       logger.error("Specified metadata names are not contained in the database."); 
    891       return OAIXML.createErrorResponse(OAIXML.NO_METADATA_FORMATS, ""); 
    892     } else { 
    893       return list_metadata_formats_response; 
    894     } 
    895   } 
    896 */ 
    897 /* 
    898   protected boolean documentContainsMetadata(DBInfo info, HashSet<String> set_of_elems) { 
    899     if (set_of_elems.size() == 0) { 
    900       return false; 
    901     } 
    902     Iterator<String> i = set_of_elems.iterator(); 
    903     while (i.hasNext()) { 
    904       if (!info.getInfo(i.next()).equals("")) { 
    905     return true; 
    906       } 
    907     } 
    908     return false; 
    909   } 
    910 */ 
    911  
    912   /** returns a list of the child ids in order, null if no children */ 
    913 /* 
    914   protected ArrayList<String> getChildrenIds(String node_id) { 
    915     DBInfo info = this.coll_db.getInfo(node_id); 
    916     if (info == null) { 
    917       return null; 
    918     } 
    919      
    920     String contains = info.getInfo("contains"); 
    921     if (contains.equals("")) { 
    922       return null; 
    923     } 
    924     ArrayList<String> children = new ArrayList<String>(); 
    925     StringTokenizer st = new StringTokenizer(contains, ";"); 
    926     while (st.hasMoreTokens()) { 
    927       String child_id = st.nextToken().replaceAll("\"", node_id); 
    928       children.add(child_id); 
    929     } 
    930     return children;     
    931   } 
    932 */ 
    933      
    934   /**method to check whether any of the 'metadata_names' is contained in the 'info'. 
    935    * The name may be in the form: <name>,<mapped name>, in which the mapped name is 
    936    * optional. The mapped name is looked up in the DBInfo; if not present, use the first 
    937    * name which is mandatory. 
    938    */ 
    939 /* 
    940   protected boolean containsMetadata(DBInfo info, String[] metadata_names) { 
    941     if (metadata_names == null) return false; 
    942     logger.info("checking metadata names in db."); 
    943     for(int i=0; i<metadata_names.length; i++) { 
    944       int index = metadata_names[i].indexOf(","); 
    945       String meta_name = (index == -1) ? metadata_names[i] : 
    946                               metadata_names[i].substring(index + 1); 
    947        
    948       if(info.getInfo(meta_name).equals("") == false) { 
    949         return true; 
    950       } 
    951     } 
    952     return false; 
    953   } 
    954 */ 
    955 /* 
    956   protected long getDateStampMillis(DBInfo info) { 
    957     // gs.OAIDateStamp is in YYYY-MM-DD 
    958     String time_stamp = info.getInfo(OAIXML.GS_OAI_DATE_STAMP); 
    959     long millis = -1; 
    960     if (!time_stamp.equals("")) { 
    961       millis = OAIXML.getTime(time_stamp); 
    962     } 
    963     if (millis == -1) { 
    964       // oailastmodified is in seconds 
    965       time_stamp = info.getInfo(OAIXML.OAI_LASTMODIFIED); 
    966       if (!time_stamp.equals("")) { 
    967     millis = Long.parseLong(time_stamp)*1000; 
    968       } 
    969     } 
    970     return millis; 
    971      
    972  
    973   } 
    974 */ 
    975339} 
    976340 
  • gs3-extensions/iiif-servlet/trunk/src/gsdl-src/java/org/greenstone/gsdl3/util/IIIFXML.java

    r32842 r32860  
    4444  public static final int ACTIVATION = 1; 
    4545   
    46   // six valid oai verbs 
     46  // one valid iiif verb // **** 
    4747  public static final String GET_RECORD = "GetRecord"; 
    48     /*     
    49   public static final String LIST_RECORDS = "ListRecords"; 
    50   public static final String LIST_IDENTIFIERS = "ListIdentifiers"; 
    51   public static final String LIST_SETS = "ListSets"; 
    52   public static final String LIST_METADATA_FORMATS = "ListMetadataFormats"; 
    53   public static final String IDENTIFY = "Identify"; 
    54     */ 
    55  
    56      
    57   // oai request parameters 
     48     
     49  // iiif request parameters 
    5850  public static final String IDENTIFIER = "identifier"; 
    59   /* 
    60   public static final String METADATA_PREFIX = "metadataPrefix"; 
    61   public static final String FROM = "from"; 
    62   public static final String UNTIL = "until"; 
    63   public static final String SET = "set"; 
    64   public static final String RESUMPTION_TOKEN = "resumptionToken"; 
    65   public static final String IDENTIFIER = "identifier"; 
    66     */ 
    6751     
    6852  // Error element and code att 
     
    7054  public static final String CODE = "code"; 
    7155   
    72   // OAI error codes 
    73       public static final String ID_DOES_NOT_EXIST = "idDoesNotExist"; 
    74     /* 
    75   public static final String BAD_ARGUMENT = "badArgument"; 
    76   public static final String BAD_RESUMPTION_TOKEN = "badResumptionToken"; 
    77   public static final String BAD_VERB = "badVerb"; 
    78   public static final String CANNOT_DISSEMINATE_FORMAT = "cannotDisseminateFormat"; 
    79   public static final String NO_METADATA_FORMATS = "noMetadataFormats"; 
    80   public static final String NO_RECORDS_MATCH = "noRecordsMatch"; 
    81   public static final String NO_SET_HIERARCHY = "noSetHierarchy"; 
    82     */ 
    83  
    84   // words used to compose oai responses 
    85   // many of these used in OAIConfig too 
     56  // IIIF error codes 
     57  public static final String ID_DOES_NOT_EXIST = "idDoesNotExist"; 
    8658 
    8759  // General 
    88     public static final String IIIF_PMH = "IIIF-PMH"; // **** 
    89   public static final String RESPONSE_DATE = "responseDate"; 
     60  public static final String IIIF_PMH = "IIIF-PMH"; // **** 
     61    public static final String RESPONSE_DATE = "responseDate"; // **** 
    9062  public static final String REQUEST = "request"; 
    91  
    92   // internal "OID" identifiers in the oai-inf db 
    93   /** represents the timestamp of the OAI collection (when its oai-inf db was first created) */ 
    94     /* 
    95   public static final String OAI_EARLIEST_TIMESTAMP_OID = "_earliesttimestamp";   
    96     */ 
    9763     
    9864  // Identify data 
    99     // OAI replacing => IIIF, maybe want baseURL and oai-identifier 
    100       public static final String BASE_URL = "baseURL"; 
    101     /* 
    102   public static final String ADMIN_EMAIL = "adminEmail"; 
     65  // OAI replacing => IIIF, maybe want baseURL and oai-identifier 
    10366  public static final String BASE_URL = "baseURL"; 
    104   public static final String COMPRESSION = "compression"; 
    105   public static final String DELETED_RECORD = "deletedRecord"; 
    106   public static final String DESCRIPTION = "description"; 
    107   public static final String EARLIEST_DATESTAMP = "earliestDatestamp"; // taken from buildconfig used as publishing date by RSS service 
    108   public static final String EARLIEST_OAI_DATESTAMP = "earliestOAIDatestamp"; // earliest timestamp of an OAI collection stored in oai-inf db 
    109   public static final String GRANULARITY = "granularity"; 
    110   public static final String LAST_MODIFIED = "lastmodified"; 
    111   public static final String PROTOCOL_VERSION = "protocolVersion"; 
    112   public static final String REPOSITORY_NAME = "repositoryName"; 
    113   public static final String OAI_IDENTIFIER = "oai-identifier"; 
    114   public static final String SCHEME = "scheme"; 
    115   public static final String REPOSITORY_IDENTIFIER = "repositoryIdentifier"; 
    116   public static final String DELIMITER = "delimiter"; 
    117   public static final String SAMPLE_IDENTIFIER = "sampleIdentifier"; 
    118     */ 
    119  
    120     /* 
    121   // metadata formats 
    122   public static final String METADATA_FORMAT = "metadataFormat"; 
    123   public static final String SCHEMA = "schema"; 
    124   public static final String METADATA_NAMESPACE = "metadataNamespace"; 
    125   public static final String META_FORMAT_DC = "oai_dc"; 
    126     */ 
    127  
    12867     
    12968  // record response data 
    13069  // SET_SPEC 
    13170  public static final String RECORD = "record"; 
    132     /* 
    133   public static final String HEADER = "header"; 
    134   public static final String DATESTAMP = "datestamp"; 
    135   public static final String METADATA = "metadata"; 
    136     */ 
    137  
    138     /* 
    139   // list sets 
    140   // SET,  
    141   public static final String SET_NAME = "setName"; 
    142   public static final String SET_SPEC = "setSpec"; 
    143   public static final String SET_DESCRIPTION = "setDescription"; 
    144     */ 
    145  
    146     /* 
    147   // resumption token element 
    148   public static final String RESUMPTION_TOKEN_ELEM = "resumptionToken"; 
    149   public static final String EXPIRATION_DATE = "expirationDate"; 
    150   public static final String COMPLETE_LIST_SIZE = "completeListSize"; 
    151   public static final String CURSOR = "cursor"; 
    152     */ 
    153      
    154   // extra elements/attributes from OAIConfig 
    155     /* 
    156   public static final String OAI_INFO = "oaiInfo"; 
    157   public static final String USE_STYLESHEET = "useOAIStylesheet"; 
    158   public static final String STYLESHEET = "OAIStylesheet"; 
    159   public static final String RESUME_AFTER = "resumeAfter"; 
    160   public static final String RESUMPTION_TOKEN_EXPIRATION = "resumptionTokenExpiration"; 
    161   public static final String OAI_SUPER_SET = "oaiSuperSet"; 
    162   public static final String ELEMENT = "element"; 
    163   public static final String ELEMENTS = "elements"; 
    164   public static final String MAPPING = "mapping"; 
    165   public static final String SELECT = "select"; 
    166   public static final String SELECT_SINGLE_VALUE = "firstvalue"; 
    167   public static final String SELECT_FIRST_VALID_META = "firstvalidmetadata"; 
    168   public static final String SELECT_ALL_VALUES = "allvalues"; 
    169   // code constants 
    170   public static final String GS_OAI_DATE_STAMP = "gs.OAIDateStamp"; 
    171    public static final String GS_OAI_RESOURCE_URL = "gs.OAIResourceURL"; 
    172   public static final String GSF_LINK_PREFIX = "gsflink."; 
    173   public static final String LINK_TYPE_DOCUMENT = "document"; 
    174   public static final String LINK_TYPE_SOURCE = "source"; 
    175    public static final String ILLEGAL_OAI_VERB = "Illegal OAI verb"; 
    176    public static final String LASTMODIFIED = "lastmodified"; 
    177   // // The node id in the collection database, which contains all the OIDs in the database 
    178    public static final String BROWSELIST = "browselist"; 
    179    public static final String OAI_LASTMODIFIED = "oailastmodified"; 
    180     */ 
    181    public static final String OAIPMH = "OAIPMH"; 
     71 
     72    public static final String OAIPMH = "OAIPMH"; // **** 
    18273     
    18374    //public static final String OAI_SET_LIST = "oaiSetList"; // **** 
    184    public static final String OAI_SERVICE_UNAVAILABLE = "OAI service unavailable"; 
    185    public static final String OID = "OID"; 
    186     /* 
    187     // The node id in the oai-inf database of the collection, which should contain all the OIDs in the db 
    188     public static final String OAI_INF_STATUS = "status"; // D = Deleted; E = Existing (PD = Provisionally Deleted but PD should not be present at this stage in the oai-inf database) 
    189     public static final String OAI_INF_TIMESTAMP = "timestamp"; // the time of deletion/last (re)indexing of doc 
    190     public static final String OAI_INF_DATESTAMP = "datestamp"; // date version of timestamp     
    191     // oai-inf db values for OAI_INF_STATUS 
    192     public static final String OAI_INF_DELETED = "D"; 
    193     public static final String OAI_INF_EXISTS = "E"; 
    194     public static final String OAI_INF_PROVISIONALLY_DELETED = "PD"; 
    195     // header values for ListRecords/GetRecord and listIdentifiers 
    196     public static final String HEADER_STATUS_ATTR_DELETED = "deleted"; 
    197     */ 
     75    //public static final String OAI_SERVICE_UNAVAILABLE = "OAI service unavailable"; 
     76    public static final String OID = "OID"; // **** 
    19877     
    19978  public static final String IIIF_SERVICE_RACK = "IIIFPMH"; 
    20079  //system-dependent file separator, maybe '/' or '\' 
    201   public static final String FILE_SEPARATOR = File.separator; 
     80  //public static final String FILE_SEPARATOR = File.separator; 
    20281    //public static final String OAI_VERSION1 = "1.0"; 
    203   public static final String IIIF_VERSION2 = "2.1"; 
     82    public static final String IIIF_VERSION2 = "2.1"; // **** 
    20483  /*************************above are final values****************************/ 
    20584     
     
    20887  public static Element iiif_config_elem = null; 
    20988     
    210   //stores the date format "yyyy-MM-ddTHH:mm:ssZ" 
    211   // this is the granularity for datestamps 
    212     /* 
    213   public static String granularity = ""; 
    214     */ 
    215      
    216   // http://www.openarchives.org/OAI/openarchivesprotocol.html#DatestampsRequests  
    217   // specifies that all repositories must support YYYY-MM-DD (yyyy-MM-dd in Java) 
    218   // this would be in addition to the other (optional) granularity of above that  
    219   // a repository may additionally choose to support. 
    220     /* 
    221   public static final String default_granularity = "yyyy-MM-dd"; 
    222     */ 
    223      
    224     //public static long token_expiration = 7200; 
    225   /** which version of oai that this oaiserver supports; default is 2.0  
    226    *  initialized in getOAIConfigXML() 
    227    */ 
    228   public static final String iiif_version = "2.1"; 
     89    public static final String iiif_version = "2.1"; // **** 
    22990  public static String baseURL = ""; 
    23091     
     
    273134      return null; 
    274135    } 
    275        
    276     //initialize oai_version 
    277     /* 
    278     Element protocol_version = (Element)GSXML.getChildByTagName(iiif_config_elem, PROTOCOL_VERSION); 
    279     iiif_version = GSXML.getNodeText(protocol_version).trim(); 
    280     */ 
    281      
     136           
    282137    // initialize baseURL 
    283138    Element base_url_elem = (Element)GSXML.getChildByTagName(iiif_config_elem, BASE_URL); 
    284139    baseURL = GSXML.getNodeText(base_url_elem); 
    285140 
    286     /* 
    287     //initialize token_expiration 
    288     Element expiration = (Element)GSXML.getChildByTagName(iiif_config_elem, RESUMPTION_TOKEN_EXPIRATION); 
    289     String expire_str = GSXML.getNodeText(expiration).trim(); 
    290     if (expiration != null && !expire_str.equals("")) { 
    291       token_expiration = Long.parseLong(expire_str); 
    292     } 
    293     */ 
    294     /* 
    295     // read granularity from the config file 
    296     Element granu_elem = (Element)GSXML.getChildByTagName(iiif_config_elem, GRANULARITY); 
    297     //initialize the granu_str which might be used by other methods (eg, getDate()) 
    298     granularity = GSXML.getNodeText(granu_elem).trim(); 
    299  
    300     //change "yyyy-MM-ddTHH:mm:ssZ" to "yyyy-MM-dd'T'HH:mm:ss'Z'" 
    301     granularity = granularity.replaceAll("T", "'T'"); 
    302     granularity = granularity.replaceAll("Z", "'Z'"); 
    303     granularity = granularity.replaceAll("YYYY", "yyyy").replaceAll("DD", "dd").replaceAll("hh", "HH"); 
    304     */ 
    305      
    306141    return iiif_config_elem; 
    307142  } 
    308143 
    309     /* 
    310   public static String[] getMetadataMapping(Element metadata_format) { 
    311  
    312     if (metadata_format == null) { 
    313       return null; 
    314     } 
    315     NodeList mappings = metadata_format.getElementsByTagName(MAPPING); 
    316     int size = mappings.getLength(); 
    317     if (size == 0) { 
    318       logger.info("No metadata mappings are provided in IIIFConfig.xml.");  
    319       return null; 
    320     } 
    321     String[] names = new String[size]; 
    322     for (int i=0; i<size; i++) { 
    323       names[i] = GSXML.getNodeText((Element)mappings.item(i)).trim(); 
    324     } 
    325     return names;       
    326      
    327   } 
    328      
    329   public static String[] getGlobalMetadataMapping(String prefix) { 
    330     Element list_meta_formats = (Element)GSXML.getChildByTagName(iiif_config_elem, LIST_METADATA_FORMATS); 
    331     if(list_meta_formats == null) { 
    332       return null; 
    333     } 
    334     Element metadata_format = GSXML.getNamedElement(list_meta_formats, METADATA_FORMAT, METADATA_PREFIX, prefix); 
    335     if(metadata_format == null) { 
    336       return null; 
    337     } 
    338     return getMetadataMapping(metadata_format); 
    339   } 
    340     */ 
    341      
    342   /** Copies out the main info from a metadataFormat element, leaving behind the mapping stuff. This gets the bit needed for OAI response */ 
    343     /* 
    344   public static Element getMetadataFormatShort(Document doc, Element meta_format_long) { 
    345     Element meta_fmt = doc.createElement(OAIXML.METADATA_FORMAT); 
    346     // Copy in the elements that we want, and ignore the rest 
    347     meta_fmt.appendChild(doc.importNode(GSXML.getChildByTagName(meta_format_long, OAIXML.METADATA_PREFIX), true)); 
    348     meta_fmt.appendChild(doc.importNode(GSXML.getChildByTagName(meta_format_long, OAIXML.SCHEMA), true)); 
    349     meta_fmt.appendChild(doc.importNode(GSXML.getChildByTagName(meta_format_long, OAIXML.METADATA_NAMESPACE), true)); 
    350  
    351     return meta_fmt; 
    352   } 
    353     */ 
    354  
    355     /* 
    356   public static long getTokenExpiration() { 
    357     return token_expiration*1000; // in milliseconds 
    358   } 
    359     */ 
    360144     
    361145  /** TODO: returns a basic response for appropriate oai version 
    362146   *   
    363147   */ 
    364   public static  Element createBasicResponse(Document doc, String verb, String[] pairs) { 
     148    public static  Element createBasicResponse(Document doc, String verb, String[] pairs) { // **** 
    365149 
    366150    Element response = createResponseHeader(doc, verb); 
     
    385169       
    386170    Node resp_date = GSXML.getChildByTagName(response, RESPONSE_DATE); // **** 
    387     /* 
    388     if (resp_date != null) { 
    389       GSXML.setNodeText((Element)resp_date, getCurrentUTCTime()); 
    390     } 
    391     */ 
    392171     
    393172    return response; 
    394173  } 
     174     
    395175  /** @param error_code the value of the code attribute 
    396176   *  @param error_text the node text of the error element 
     
    497277   *  escaped sequences (eg, '%3A').  
    498278   */ 
    499   public static String oaiEncode(String original_str) { 
     279    public static String oaiEncode(String original_str) { // **** 
    500280    logger.info("oaiEncode() " + original_str);       
    501281    for (int i=0; i<special_char.length; i++) { 
     
    506286    return original_str;   
    507287  } 
    508   /** convert YYYY-MM_DDThh:mm:ssZ to yyyy-MM-ddTHH:mm:ssZ 
    509    */ 
    510     /* 
    511   public static String convertToJava(String oai_format) { 
    512     oai_format = oai_format.replaceAll("YYYY", "yyyy").replaceAll("DD", "dd").replaceAll("hh", "HH"); 
    513     return oai_format; 
    514   } 
    515     */ 
    516   /** convert yyyy-MM-ddTHH:mm:ssZ to YYYY-MM_DDThh:mm:ssZ 
    517    */ 
    518     /* 
    519   public static String convertToOAI(String java_format) { 
    520     java_format = java_format.replaceAll("yyyy", "YYYY").replaceAll("dd", "DD").replaceAll("HH", "hh"); 
    521     return java_format;       
    522   }     
    523   public static String getCurrentUTCTime() { 
    524     Date current_utc = new Date(System.currentTimeMillis()); 
    525     //granularity is in the form: yyyy-MM-dd'T'HH:mm:ss'Z ' 
    526     DateFormat formatter = new SimpleDateFormat(granularity); 
    527     return formatter.format(current_utc); 
    528   } 
    529     */ 
    530   /** get a Date object from a Date format pattern string 
    531    * 
    532    * @param pattern - in the form: 2007-06-14T16:48:25Z, for example. 
    533    * @return a Date object - null if the pattern is not in the specified form 
    534    */ 
    535     /* 
    536   public static Date getDate(String pattern) { 
    537     if (pattern == null || pattern.equals("")) { 
    538       return null; 
    539     } 
    540     Date date = null; 
    541     //      String str = pattern.replaceAll("T", " "); 
    542     //      str = str.replaceAll("Z", ""); 
    543     SimpleDateFormat sdf = null; 
    544     try { 
    545       sdf = new SimpleDateFormat(granularity); 
    546       date = sdf.parse(pattern); 
    547     } catch(Exception e) { 
    548       if(!default_granularity.equals(granularity)) { // try validating against default granularity 
    549     try { 
    550       date = null; 
    551       sdf = null; 
    552       sdf = new SimpleDateFormat(default_granularity); 
    553       date = sdf.parse(pattern); 
    554     } catch(Exception ex) { 
    555       logger.error("invalid date format: " + pattern); 
    556       return null; 
    557     } 
    558       } else { 
    559     logger.error("invalid date format: " + pattern); 
    560     return null; 
    561       } 
    562     } 
    563     return date; 
    564   } 
    565     */ 
    566   /** get the million second value from a string representing time in a pattern 
    567    * (eg, 2007-06-14T16:48:25Z) 
    568    */ 
    569     /* 
    570   public static long getTime(String pattern) { 
    571     if (pattern == null || pattern.equals("")) { 
    572       return -1; 
    573     } 
    574     Date date = null; 
    575     SimpleDateFormat sdf = null; 
    576     try { 
    577       //granularity is a global variable in the form: yyyy-MM-ddTHH:mm:ssZ  
    578       sdf = new SimpleDateFormat(granularity); 
    579       date = sdf.parse(pattern); 
    580     } catch(Exception e) { 
    581       if(!default_granularity.equals(granularity)) { // try validating against default granularity 
    582     try { 
    583       date = null; 
    584       sdf = null; 
    585       sdf = new SimpleDateFormat(default_granularity); 
    586       date = sdf.parse(pattern); 
    587     } catch(Exception ex) { 
    588       logger.error("invalid date format: " + pattern); 
    589       return -1; 
    590     } 
    591       } else { 
    592     logger.error("invalid date format: " + pattern); 
    593     return -1; 
    594       }         
    595     } 
    596     return date.getTime(); 
    597   }    
    598     */  
    599   /** get the string representation of a time from a long value(long type) 
    600    */ 
    601     /* 
    602   public static String getTime(long milliseconds) { 
    603     Date date = new Date(milliseconds); 
    604     SimpleDateFormat sdf = new SimpleDateFormat(granularity); 
    605     return sdf.format(date); 
    606   }    
    607     */  
     288 
    608289  public static Element createResponseHeader(Document response_doc, String verb) { 
    609290      String tag_name = (iiif_version.equals(IIIF_VERSION2))? IIIF_PMH : verb; // **** 
    610291    Element oai = response_doc.createElement(tag_name); 
    611     Element resp_date = response_doc.createElement(RESPONSE_DATE); 
     292    Element resp_date = response_doc.createElement(RESPONSE_DATE); // **** 
    612293    Element req = response_doc.createElement(REQUEST); 
    613294    oai.appendChild(resp_date); 
     
    626307  } 
    627308 
    628     /* 
    629   public static Element getMetadataPrefixElement(Document doc, String prefix, Element meta_format) { 
    630  
    631     Element ns_elem = (Element)GSXML.getChildByTagName(meta_format, METADATA_NAMESPACE); 
    632     String namespace = null; 
    633     if (ns_elem != null) { 
    634       namespace = GSXML.getNodeText(ns_elem); 
    635     } 
    636     if (namespace == null || namespace.equals("")) { 
    637       logger.error("No namespace URI found in metadataFormat elemnt for "+prefix); 
    638       logger.error(XMLConverter.getPrettyString(meta_format)); 
    639       return null; 
    640     } 
    641  
    642     Element sc_elem = (Element)GSXML.getChildByTagName(meta_format, SCHEMA); 
    643     String schema = null; 
    644     if (sc_elem != null) { 
    645       schema = GSXML.getNodeText(sc_elem); 
    646     } 
    647     if (schema == null || schema.equals("")) { 
    648       logger.error("No schema found in metadataFormat element for "+prefix); 
    649       logger.error(XMLConverter.getPrettyString(meta_format)); 
    650       return null; 
    651     } 
    652        
    653     String tag_name = getMetadataTagName(prefix, oai_version); 
    654     Element oai = doc.createElement(tag_name); 
    655     oai.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"); 
    656      
    657     if (oai_version.equals(OAI_VERSION2)) { 
    658       oai.setAttribute("xmlns:"+prefix, namespace); 
    659       if (prefix.equals(META_FORMAT_DC)) { 
    660     // there seems to be an extra one for dc 
    661     oai.setAttribute("xmlns:dc", "http://purl.org/dc/elements/1.1/"); 
    662       } 
    663       oai.setAttribute("xsi:schemaLocation", namespace+" \n "+schema); 
    664     } else { 
    665       oai.setAttribute("xmlns", "http://www.openarchives.com/OAI/1.1/"); 
    666       if (prefix.equals(META_FORMAT_DC)) { 
    667     oai.setAttribute("xsi:schemaLocation", "http://www.openarchives.org/OAI/1.1/" + tag_name + ".xsd"); 
    668       } else { 
    669     oai.setAttribute("xsi:schemaLocation", schema); 
    670       } 
    671     } 
    672  
    673     return oai; 
    674      
    675   } 
    676      
    677   public static String getMetadataTagName(String prefix, String oai_version) { 
    678     if (prefix.equals(META_FORMAT_DC)) { 
    679       if (oai_version.equals(OAI_VERSION2)) { 
    680     return "oai_dc:dc"; 
    681       } 
    682       return "dc"; 
    683     } 
    684     return prefix; 
    685   } 
    686  
    687   public static HashMap<String, Node> getChildrenMapByTagName(Node n, String tag_name) { 
    688      
    689     HashMap<String, Node> map= new HashMap<String, Node>(); 
    690     Node child = n.getFirstChild(); 
    691     while (child!=null) { 
    692       String name = child.getNodeName(); 
    693       if(name.equals(tag_name)) { 
    694     map.put(name, child); 
    695       } 
    696       child = child.getNextSibling(); 
    697     } 
    698     return map; 
    699   } 
    700     */ 
    701309     
    702310  public static Element createOAIIdentifierXML(Document doc, String repository_id, String sample_collection, String sample_doc_id) { 
     
    712320    String xml = "<gsdl xmlns=\"http://www.greenstone.org/namespace/gsdl_oaiinfo/1.0/gsdl_oaiinfo\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xsi:schemaLocation=\"http://www.greenstone.org/namespace/gsdl_oaiinfo/1.0/gsdl_oaiinfo\n   http://www.greenstone.org/namespace/gsdl_oaiinfo/1.0/gsdl_oaiinfo.xsd\"></gsdl>"; 
    713321    Document xml_doc = converter.getDOM(xml); 
    714     return (Element)doc.importNode(xml_doc.getDocumentElement(), true); 
    715      
    716  
    717   } 
    718     /* 
    719   public static Element createSet(Document doc, String spec, String name, String description) { 
    720  
    721     Element set_elem = doc.createElement(SET); 
    722     Element set_spec = doc.createElement(SET_SPEC); 
    723     GSXML.setNodeText(set_spec, spec); 
    724     set_elem.appendChild(set_spec); 
    725     Element set_name = doc.createElement(SET_NAME); 
    726     GSXML.setNodeText(set_name, name); 
    727     set_elem.appendChild(set_name); 
    728     if (description != null) { 
    729       Element set_description = doc.createElement(SET_DESCRIPTION); 
    730       GSXML.setNodeText(set_description, description); 
    731       set_elem.appendChild(set_description); 
    732     } 
    733     return set_elem; 
    734      
    735   } 
    736     */ 
    737      
    738   /** returns the resumptionToken element to go into an OAI response */ 
    739     /* 
    740   public static Element createResumptionTokenElement(Document doc, String token_name, int total_size, int cursor, long expiration_time) { 
    741     Element token = doc.createElement(OAIXML.RESUMPTION_TOKEN); 
    742     if (total_size != -1) { 
    743       token.setAttribute(OAIXML.COMPLETE_LIST_SIZE, "" + total_size); 
    744     } 
    745     if (cursor != -1) { 
    746       token.setAttribute(OAIXML.CURSOR, "" + cursor); 
    747     } 
    748     if(expiration_time !=-1) { 
    749       token.setAttribute(OAIXML.EXPIRATION_DATE, getTime(expiration_time)); 
    750     } 
    751     
    752     if (token != null) { 
    753       GSXML.setNodeText(token, token_name); 
    754     } 
    755     return token; 
    756   } 
    757     */ 
     322    return (Element)doc.importNode(xml_doc.getDocumentElement(), true);     
     323  } 
    758324} 
    759325