Ignore:
Timestamp:
2011-07-04T10:49:50+12:00 (13 years ago)
Author:
sjm84
Message:

Added more functionality to ArchiveRetrieve, added an additonal parameter to printXMLNode in GSXML that controls whether text nodes are to be printed or not and also made the infodb type of collections more easily accessible

File:
1 edited

Legend:

Unmodified
Added
Removed

  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/service/ArchiveRetrieve.java

    r24211 r24221  
    11/*
    2 *    AbstractDocumentRetrieve.java
     2*    ArchiveRetrieve.java
    33*    a base class for retrieval services
    44
    … …  
    2121package org.greenstone.gsdl3.service;
    2222
     23import org.greenstone.gsdl3.util.DBInfo;
    2324import org.greenstone.gsdl3.util.GSPath;
    2425import org.greenstone.gsdl3.util.GSXML;
    … …  
    3132import java.io.File;
    3233import java.util.HashMap;
    33 
    34 /** Abstract class for Document Retrieval Services
    35 *
    36 * @author <a href="mailto:[email protected]">Katherine Don</a>
    37 */
    38 
    39 public class ArchiveRetrieve extends ServiceRack {
    40 
     34import java.util.Vector;
     35
     36public class ArchiveRetrieve extends ServiceRack
     37{
    4138    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.service.ArchiveRetrieve.class.getName());
    4239
    43     protected static final String ARCHIVE_FILE_PATH_RETRIEVE_SERVICE = "ArchiveFilePathRetrieve";
     40    protected static final String DOCUMENT_FILE_PATH_RETRIEVE_SERVICE = "DocumentFilePathRetrieve";
     41    protected static final String ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE = "AssociatedImportFilesRetrieve";
     42    protected static final String SOURCE_FILE_OID_RETRIEVE = "SourceFileOIDRetrieve";
    4443   
    4544    protected SimpleCollectionDatabase coll_db = null;
    46    
    47     /** constructor */
    48     public ArchiveRetrieve()
    49     {
    50     }
    5145
    5246    /** configure this service */
    5347    public boolean configure(Element info, Element extra_info)
    5448    {
    55         if (!super.configure(info, extra_info)){
     49        if (!super.configure(info, extra_info))
     50        {
    5651            return false;
    5752        }
    … …  
    6055        this.config_info = info;
    6156       
    62         Element archiveFilePathRetrieveService = this.doc.createElement(GSXML.SERVICE_ELEM);
    63         archiveFilePathRetrieveService.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
    64         archiveFilePathRetrieveService.setAttribute(GSXML.NAME_ATT, ARCHIVE_FILE_PATH_RETRIEVE_SERVICE);
    65         this.short_service_info.appendChild(archiveFilePathRetrieveService);
     57        Element documentFilePathRetrieveService = this.doc.createElement(GSXML.SERVICE_ELEM);
     58        documentFilePathRetrieveService.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     59        documentFilePathRetrieveService.setAttribute(GSXML.NAME_ATT, DOCUMENT_FILE_PATH_RETRIEVE_SERVICE);
     60        this.short_service_info.appendChild(documentFilePathRetrieveService);
     61       
     62        Element associatedImportFilesRetrieveService = this.doc.createElement(GSXML.SERVICE_ELEM);
     63        associatedImportFilesRetrieveService.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     64        associatedImportFilesRetrieveService.setAttribute(GSXML.NAME_ATT, ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE);
     65        this.short_service_info.appendChild(associatedImportFilesRetrieveService);
     66       
     67        Element sourceFileDocIDRetrieveService = this.doc.createElement(GSXML.SERVICE_ELEM);
     68        sourceFileDocIDRetrieveService.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     69        sourceFileDocIDRetrieveService.setAttribute(GSXML.NAME_ATT, SOURCE_FILE_OID_RETRIEVE);
     70        this.short_service_info.appendChild(sourceFileDocIDRetrieveService);
    6671       
    6772        return true;
    … …  
    7075    protected Element getServiceDescription(String service_id, String lang, String subset)
    7176    {
    72         Element service_elem = this.doc.createElement(GSXML.SERVICE_ELEM);
    73         service_elem.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
    74         service_elem.setAttribute(GSXML.NAME_ATT, ARCHIVE_FILE_PATH_RETRIEVE_SERVICE);
    75         return service_elem;
    76     }
    77    
    78     protected Element processArchiveFilePathRetrieve(Element request)
     77        if (service_id.equals(DOCUMENT_FILE_PATH_RETRIEVE_SERVICE))
     78        {
     79            Element service_elem = this.doc.createElement(GSXML.SERVICE_ELEM);
     80            service_elem.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     81            service_elem.setAttribute(GSXML.NAME_ATT, DOCUMENT_FILE_PATH_RETRIEVE_SERVICE);
     82            return service_elem;
     83        }
     84        else if (service_id.equals(ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE))
     85        {
     86            Element service_elem = this.doc.createElement(GSXML.SERVICE_ELEM);
     87            service_elem.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     88            service_elem.setAttribute(GSXML.NAME_ATT, ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE);
     89            return service_elem;
     90        }
     91        else if (service_id.equals(SOURCE_FILE_OID_RETRIEVE))
     92        {
     93            Element service_elem = this.doc.createElement(GSXML.SERVICE_ELEM);
     94            service_elem.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_RETRIEVE);
     95            service_elem.setAttribute(GSXML.NAME_ATT, SOURCE_FILE_OID_RETRIEVE);
     96            return service_elem;
     97        }
     98        return null;
     99    }
     100   
     101    protected Element processDocumentFilePathRetrieve(Element request)
    79102    {
    80103        // Create a new (empty) result message
    81104        Element result = this.doc.createElement(GSXML.RESPONSE_ELEM);
    82         result.setAttribute(GSXML.FROM_ATT, ARCHIVE_FILE_PATH_RETRIEVE_SERVICE);
     105        result.setAttribute(GSXML.FROM_ATT, DOCUMENT_FILE_PATH_RETRIEVE_SERVICE);
    83106        result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
    84107       
    … …  
    89112        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    90113        if (param_list == null) {
    91             GSXML.addError(this.doc, result, "DocumentMetadataRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
     114            GSXML.addError(this.doc, result, "DocumentFilePathRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
    92115            return result; 
    93116        }
    94117        HashMap params = GSXML.extractParams(param_list, false);
    95118       
    96         String docID = (String) params.get("docID");
     119        String oid = (String) params.get("oid");
    97120        String collection = (String) params.get("c");
    98121       
    99         String assocFilePath = getAssocFilePathFromDocID(docID, collection, lang, uid);
     122        String assocFilePath = getAssocFilePathFromDocID(oid, collection, lang, uid);
    100123       
    101124        String docFilePath = this.site_home + File.separatorChar +
    … …  
    105128            assocFilePath + File.separatorChar +
    106129            "doc.xml";
    107        
    108         Element metaElem = this.doc.createElement(GSXML.METADATA_ELEM);
    109         metaElem.setAttribute("name", "docFilePath");
    110         metaElem.setAttribute("value", docFilePath);
    111        
    112         logger.error("DOCFILEPATH = " + docFilePath);
    113        
    114         result.appendChild(metaElem);
     130
     131        Element metadataList = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
     132        metadataList.appendChild(createMetadataElement("docfilepath", docFilePath));
     133        result.appendChild(metadataList);
    115134       
    116135        return result;
    117136    }
    118137   
    119     protected Element processArchiveAssociatedImportFilesRetrieve(Element request)
    120     {
    121         // find out what kind of database we have
    122         //Element database_type_elem = (Element) GSXML.getChildByTagName(this.config_info, GSXML.DATABASE_TYPE_ELEM);
    123         //String database_type = "jdbm";
    124         /*if (database_type_elem != null) {
    125             database_type = database_type_elem.getAttribute(GSXML.NAME_ATT);
    126         }
    127         if (database_type == null || database_type.equals("")) {
    128             database_type = "gdbm"; // the default
    129         }
    130        
    131         String db_ext = null;
    132         if (database_type.equalsIgnoreCase("jdbm")) {
    133             db_ext = ".jdb";
    134         } else {
    135             db_ext = ".gdb"; // assume gdbm
    136         }
    137        
    138        
    139                 coll_db = new SimpleCollectionDatabase(database_type);
    140         if (!coll_db.databaseOK()) {
    141             logger.error("Couldn't create the collection database of type "+database_type);
     138    protected Element processSourceFileOIDRetrieveService(Element request)
     139    {
     140        //Create a new (empty) result message
     141        Element result = this.doc.createElement(GSXML.RESPONSE_ELEM);
     142        result.setAttribute(GSXML.FROM_ATT, SOURCE_FILE_OID_RETRIEVE);
     143        result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
     144       
     145        String lang = request.getAttribute(GSXML.LANG_ATT);
     146        String uid = request.getAttribute(GSXML.USER_ID_ATT);
     147       
     148        // Get the parameters of the request
     149        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     150        if (param_list == null)
     151        {
     152            GSXML.addError(this.doc, result, "DocumentFilePathRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
     153            return result; 
     154        }
     155        HashMap params = GSXML.extractParams(param_list, false);
     156       
     157        String srcFile = (String) params.get("srcfile");
     158        String collection = (String) params.get("c");
     159       
     160        //Find out what kind of database we have
     161        String databaseType = getDatabaseTypeFromCollection(collection, lang, uid);
     162        if (databaseType == null || databaseType.equals(""))
     163        {
     164            databaseType = "gdbm"; // the default
     165        }
     166       
     167        String dbExt = null;
     168        if (databaseType.equalsIgnoreCase("jdbm"))
     169        {
     170            dbExt = ".jdb";
     171        }
     172        else
     173        {
     174            dbExt = ".gdb"; // assume gdbm
     175        }
     176       
     177        coll_db = new SimpleCollectionDatabase(databaseType);
     178        if (!coll_db.databaseOK())
     179        {
     180            logger.error("Couldn't create the collection database of type "+databaseType);
    142181            return null;
    143182        }
    144         */
    145    
    146             /*coll_db.openDatabase(
     183
     184        coll_db.openDatabase
     185        (
    147186            this.site_home + File.separatorChar +
    148187            "collect" + File.separatorChar +
    149188            collection + File.separatorChar +
    150189            "archives" + File.separatorChar +
    151             "archiveinf-doc" + db_ext,
    152             SimpleCollectionDatabase.READ);
    153        
    154         logger.error("STUFF " + coll_db.getInfo(docID));
    155        
    156         coll_db.getInfo(docID);*/
    157         return null;
    158     }
    159    
    160     public String getAssocFilePathFromDocID(String docID, String collection, String lang, String uid)
     190            "archiveinf-src" + dbExt,
     191            SimpleCollectionDatabase.READ
     192        );
     193       
     194        DBInfo info = coll_db.getInfo(srcFile);
     195       
     196        if (info == null)
     197        {
     198            return result;
     199        }
     200       
     201        String oid = info.getInfo("oid");
     202       
     203        Element metadataList = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
     204        metadataList.appendChild(createMetadataElement("oid", oid));
     205        result.appendChild(metadataList);
     206       
     207        return result;
     208    }
     209   
     210    protected Element processAssociatedImportFilesRetrieve(Element request)
     211    {
     212        //Create a new (empty) result message
     213        Element result = this.doc.createElement(GSXML.RESPONSE_ELEM);
     214        result.setAttribute(GSXML.FROM_ATT, ASSOCIATED_IMPORT_FILES_RETRIEVE_SERVICE);
     215        result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
     216       
     217        String lang = request.getAttribute(GSXML.LANG_ATT);
     218        String uid = request.getAttribute(GSXML.USER_ID_ATT);
     219       
     220        // Get the parameters of the request
     221        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
     222        if (param_list == null)
     223        {
     224            GSXML.addError(this.doc, result, "AssociatedImportFilesRetrieve: missing "+ GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER, GSXML.ERROR_TYPE_SYNTAX);
     225            return result; 
     226        }
     227        HashMap params = GSXML.extractParams(param_list, false);
     228       
     229        String oid = (String) params.get("oid");
     230        String collection = (String) params.get("c");
     231       
     232        String databaseType = getDatabaseTypeFromCollection(collection, lang, uid);
     233        if (databaseType == null || databaseType.equals(""))
     234        {
     235            databaseType = "gdbm"; // the default
     236        }
     237       
     238        String dbExt = null;
     239        if (databaseType.equalsIgnoreCase("jdbm"))
     240        {
     241            dbExt = ".jdb";
     242        }
     243        else
     244        {
     245            dbExt = ".gdb"; // assume gdbm
     246        }
     247       
     248        coll_db = new SimpleCollectionDatabase(databaseType);
     249        if (!coll_db.databaseOK())
     250        {
     251            logger.error("Couldn't create the collection database of type "+databaseType);
     252            return null;
     253        }
     254
     255        coll_db.openDatabase
     256        (
     257            this.site_home + File.separatorChar +
     258            "collect" + File.separatorChar +
     259            collection + File.separatorChar +
     260            "archives" + File.separatorChar +
     261            "archiveinf-doc" + dbExt,
     262            SimpleCollectionDatabase.READ
     263        );
     264       
     265        DBInfo info = coll_db.getInfo(oid);
     266       
     267        if (info == null)
     268        {
     269            return result;
     270        }
     271       
     272        String srcFile = info.getInfo("src-file");
     273        Vector data = info.getMultiInfo("assoc-file");
     274       
     275        Element metadataList = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
     276        metadataList.appendChild(createMetadataElement("srcfile", srcFile));
     277       
     278        for (int i = 0; i < data.size(); i++)
     279        {
     280            metadataList.appendChild(createMetadataElement("assocfile", (String)data.get(i)));
     281        }
     282       
     283        result.appendChild(metadataList);
     284       
     285        return result;
     286    }
     287   
     288    public Element createMetadataElement(String name, String value)
     289    {
     290        Element metaElem = this.doc.createElement(GSXML.METADATA_ELEM);
     291        metaElem.setAttribute("name", name);
     292        metaElem.setAttribute("value", value);
     293        return metaElem;
     294    }
     295   
     296    public String getAssocFilePathFromDocID(String oid, String collection, String lang, String uid)
    161297    {
    162298        Element mr_query_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
    … …  
    165301       
    166302        Element paramList = this.doc.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    167 
    168         Element assocParam = this.doc.createElement(GSXML.PARAM_ELEM);
    169         assocParam.setAttribute("name", "metadata");
    170         assocParam.setAttribute("value", "assocfilepath");
    171         paramList.appendChild(assocParam);
     303        paramList.appendChild(createMetadataElement("metadata", "assocfilepath"));
    172304       
    173305        mr_query_request.appendChild(paramList);
    174306
    175         Element docList = this.doc.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
    176         Element doc = this.doc.createElement(GSXML.DOC_NODE_ELEM);
    177         doc.setAttribute(GSXML.NODE_ID_ATT, docID);
    178         docList.appendChild(doc);
    179         mr_query_request.appendChild(docList);
     307        Element docListElem = this.doc.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
     308        Element docElem = this.doc.createElement(GSXML.DOC_NODE_ELEM);
     309        docElem.setAttribute(GSXML.NODE_ID_ATT, oid);
     310        docListElem.appendChild(docElem);
     311        mr_query_request.appendChild(docListElem);
    180312
    181313        Element response = (Element) this.router.process(mr_query_message);
    … …  
    189321        return metadataElem.getFirstChild().getNodeValue();
    190322    }
     323   
     324    public String getDatabaseTypeFromCollection(String collection, String lang, String uid)
     325    {
     326        //Find out what kind of database we have
     327        Element dbTypeMessage = this.doc.createElement(GSXML.MESSAGE_ELEM);
     328        Element dbTypeRequest = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE, collection, lang, uid);
     329        dbTypeMessage.appendChild(dbTypeRequest);
     330        Element dbTypeResponse = (Element)this.router.process(dbTypeMessage);
     331       
     332        String path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.COLLECTION_ELEM);
     333        Element collectionElem = (Element) GSXML.getNodeByPath(dbTypeResponse, path);
     334       
     335        if (collectionElem != null)
     336        {
     337            return collectionElem.getAttribute(GSXML.DB_TYPE_ATT);
     338        }
     339        return null;
     340    }
    191341}   
Note: See TracChangeset for help on using the changeset viewer.