Changeset 6504 for TI01-discovery-API


Ignore:
Timestamp:
05/02/10 11:54:58 (9 years ago)
Author:
mnagni
Message:

Added support in DoSearch? for: Start, HowMany?, Scope, OrderBy?, TemporalSearch?(still not tested)

Updated some Exception classes to support the constructor (NdgMessage?, Throwable)

Location:
TI01-discovery-API/trunk/MEDINDiscoveryService/src/main
Files:
2 added
1 deleted
10 edited

Legend:

Unmodified
Added
Removed
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/common/exception/NdgException.java

    r6456 r6504  
    3939                this.bundleMessage = bundleMessage; 
    4040        } 
     41         
     42        public NdgException(NdgMessage bundleMessage, Throwable th) { 
     43                super(th); 
     44                this.bundleMessage = bundleMessage; 
     45        } 
    4146} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/common/exception/NdgSQLException.java

    r6465 r6504  
    3434        } 
    3535 
     36        public NdgSQLException(NdgMessage bundleMessage, Throwable th) { 
     37                super(th); 
     38        } 
    3639} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/common/exception/ResourceNotAvailable.java

    r6456 r6504  
    3939                // TODO Auto-generated constructor stub 
    4040        } 
     41        public ResourceNotAvailable(NdgMessage bundleMessage, Throwable th) { 
     42                super(th); 
     43        } 
    4144} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/common/messages.properties

    r6456 r6504  
    55sql.resultset.parsing.error = Error occurred parsing the result from the following SQL: \n {0} 
    66sql.command = Executing \n {0} 
     7invocation.error = The command {0} generated an unexpected exception 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/DiscoveryServiceMEDINSkeleton.java

    r6465 r6504  
    11package ndg.services.discovery; 
    22 
    3 import java.util.Set; 
    4  
     3import java.beans.PropertyDescriptor; 
     4import java.lang.reflect.InvocationTargetException; 
     5import java.util.List; 
     6 
     7import ndg.common.NdgMessage; 
    58import ndg.common.exception.NdgSQLException; 
    69import ndg.common.exception.ResourceNotAvailable; 
     
    811import ndg.services.discovery.exception.DiscoveryWSException; 
    912import ndg.services.discovery.medin.DiscoveryDictionary; 
    10 import ndg.services.discovery.medin.Utilities; 
    11 import ndg.services.discovery.model.MEDINSearchResult; 
     13import ndg.services.discovery.medin.DiscoveryDictionary.OrderByField; 
    1214import ndg.services.discovery.model.SearchAgent; 
     15import ndg.services.jpa.OriginalDocument; 
    1316 
    1417import org.apache.log4j.Logger; 
     
    1720import discoveryserviceapi.DoSearchDocument; 
    1821import discoveryserviceapi.DoSearchReturnDocument; 
     22import discoveryserviceapi.OrderByType; 
     23import discoveryserviceapi.OrderingMetricType; 
    1924import discoveryserviceapi.ReturnBriefType; 
    2025import discoveryserviceapi.ReturnFullType; 
    2126import discoveryserviceapi.ReturnSummaryType; 
    2227import discoveryserviceapi.SearchReturnType; 
     28import discoveryserviceapi.SearchType; 
    2329import discoveryserviceapi.SearchReturnType.Documents; 
    2430 
     
    3238        // Lists to provide according to 
    3339        // http://proj.badc.rl.ac.uk/ndg/wiki/Discovery/DiscoveryWebServiceMEDIN#TermLists 
    34         public static final String[] LIST_NAMES = { "TermTargetList", 
    35                         "PresentFormatList", "OrderByFieldList", "ScopeList", 
    36                         "SpatialOperatorList", "SpatialReferenceSystemList", 
    37                         "DateRangeTargetList", "TemporalOperatorList", 
     40        public static final String[] LIST_NAMES = { "TermTargetList", "PresentFormatList", "OrderByFieldList", "ScopeList", 
     41                        "SpatialOperatorList", "SpatialReferenceSystemList", "DateRangeTargetList", "TemporalOperatorList", 
    3842                        "MetadataFormatList", "RecordDetailList" }; 
    3943 
     
    4347        // Terms for : TermTargetList 
    4448 
    45         //public static final String FULLTEXT_TERMTARGET = "FullText"; 
    46         //public static final String AUTHOR_TERMTARGET = "Author"; 
    47         //public static final String PARAMETER_TERMTARGET = "Parameter"; 
    48         //public static final String MEDIN_TERM_TARGET_TERMTARGET = "MEDINTermTarget.1"; 
     49        // public static final String FULLTEXT_TERMTARGET = "FullText"; 
     50        // public static final String AUTHOR_TERMTARGET = "Author"; 
     51        // public static final String PARAMETER_TERMTARGET = "Parameter"; 
     52        // public static final String MEDIN_TERM_TARGET_TERMTARGET = 
     53        // "MEDINTermTarget.1"; 
    4954 
    5055        // Terms for : PresentFormatList 
     
    8994 
    9095        // Terms for : DateRangeTargetList 
    91         public static final String TEMPORALCOVERAGE_DATERANGETARGET = "TemporalCoverage"; 
    92         public static final String LASTREVISIONDATE_DATERANGETARGET = "LastRevisionDate"; 
    93         public static final String DISCOVERYINGESTDATE_DATERANGETARGET = "DiscoveryIngestDate"; 
    94  
     96        /* 
     97         * public static final String TEMPORALCOVERAGE_DATERANGETARGET = 
     98         * "TemporalCoverage"; public static final String 
     99         * LASTREVISIONDATE_DATERANGETARGET = "LastRevisionDate"; public static 
     100         * final String DISCOVERYINGESTDATE_DATERANGETARGET = "DiscoveryIngestDate"; 
     101         */ 
    95102        // Terms for : TemporalOperatorList 
    96         public static final String EQUALS_TEMPORALOPERATOR = "Equals"; 
    97         public static final String DOESNOTEQUAL_TEMPORALOPERATOR = "DoesNotEqual"; 
    98         public static final String ONORBEFORE_TEMPORALOPERATOR = "OnOrBefore"; 
    99         public static final String ONORAFTER_TEMPORALOPERATOR = "OnOrAfter"; 
    100         public static final String BEFORE_TEMPORALOPERATOR = "Before"; 
    101         public static final String AFTER_TEMPORALOPERATOR = "After"; 
     103        /* 
     104         * public static final String EQUALS_TEMPORALOPERATOR = "Equals"; public 
     105         * static final String DOESNOTEQUAL_TEMPORALOPERATOR = "DoesNotEqual"; 
     106         * public static final String ONORBEFORE_TEMPORALOPERATOR = "OnOrBefore"; 
     107         * public static final String ONORAFTER_TEMPORALOPERATOR = "OnOrAfter"; 
     108         * public static final String BEFORE_TEMPORALOPERATOR = "Before"; public 
     109         * static final String AFTER_TEMPORALOPERATOR = "After"; 
     110         */ 
    102111 
    103112        // Terms for : MetadataFormatList 
     
    110119        // Terms for : RecordDetailList 
    111120 
    112         //public static final String ID_RECORDDETAIL = "Id"; 
    113         //public static final String BRIEF_RECORDDETAIL = "Brief"; 
    114         //public static final String SUMMARY_RECORDDETAIL = "Summary"; 
     121        // public static final String ID_RECORDDETAIL = "Id"; 
     122        // public static final String BRIEF_RECORDDETAIL = "Brief"; 
     123        // public static final String SUMMARY_RECORDDETAIL = "Summary"; 
    115124 
    116125        // Other constants 
     
    138147                // throw new java.lang.UnsupportedOperationException("Please implement " 
    139148                // + this.getClass().getName() + "#getListNames"); 
    140                  
    141149 
    142150                /*--- Generated by WSDL2Code, DO NOT TOUCH ---*/ 
    143151                discoveryserviceapi.GetListNamesReturnDocument response = discoveryserviceapi.GetListNamesReturnDocument.Factory 
    144152                                .newInstance(); 
    145                 discoveryserviceapi.GetListNamesReturnType responseContent = response 
    146                                 .addNewGetListNamesReturn(); 
    147                 discoveryserviceapi.GetListNamesReturnType.ListNames listNames = responseContent 
    148                                 .addNewListNames(); 
     153                discoveryserviceapi.GetListNamesReturnType responseContent = response.addNewGetListNamesReturn(); 
     154                discoveryserviceapi.GetListNamesReturnType.ListNames listNames = responseContent.addNewListNames(); 
    149155                /*--- Generated by WSDL2Code, DO NOT TOUCH ---*/ 
    150                  
     156 
    151157                if (logger.isInfoEnabled()) { 
    152                         logger.info("getListNames() invoked");   
    153                 } 
    154                  
     158                        logger.info("getListNames() invoked"); 
     159                } 
     160 
    155161                for (int i = 0; i < LIST_NAMES.length; i++) { 
    156162                        listNames.addListName(LIST_NAMES[i]); 
    157163                        if (logger.isDebugEnabled()) { 
    158                                 logger.debug("Added name: " + LIST_NAMES[i]);    
    159                         }                        
    160                 }                
     164                                logger.debug("Added name: " + LIST_NAMES[i]); 
     165                        } 
     166                } 
    161167 
    162168                if (logger.isInfoEnabled()) { 
    163                         logger.info("getListNames() completed successfully");    
     169                        logger.info("getListNames() completed successfully"); 
    164170                } 
    165171 
     
    174180         */ 
    175181 
    176         public DoSearchReturnDocument doSearch( 
    177                         DoSearchDocument doSearch) { 
    178                  
    179                 //generate a consistent ID for use within this session 
    180                 //final String thisSessionID = Utilities.generateSessionID();  
    181                  
     182        public DoSearchReturnDocument doSearch(DoSearchDocument doSearch) { 
     183 
     184                // generate a consistent ID for use within this session 
     185                // final String thisSessionID = Utilities.generateSessionID(); 
     186 
    182187                DoSearchReturnDocument response = DoSearchReturnDocument.Factory.newInstance(); 
    183188                SearchReturnType responseContent = response.addNewDoSearchReturn(); 
     
    187192                String statusMessage = "Normal"; 
    188193                try { 
    189                         Set<MEDINSearchResult> result = agent.doSearch(); 
    190                         DiscoveryDictionary.RecordDetailList type  
    191                                 = Utilities.getRecordDetails(doSearch.getDoSearch().getRecordDetail()); 
    192                          
    193                         processResult(result,  
    194                                         responseContent.addNewDocuments(), type);        
    195                          
    196                         status = (result != null && result.size() > 0 ? true : false);                   
     194                        List<OriginalDocument> result = agent.doSearch(); 
     195                        processResult(result, responseContent.addNewDocuments(), doSearch.getDoSearch()); 
     196 
     197                        status = (result != null && result.size() > 0 ? true : false); 
    197198                } catch (NdgSQLException e) { 
    198199                        statusMessage = e.getMessage(); 
     
    202203                        responseContent.setStatus(status); 
    203204                        responseContent.setStatusMessage(statusMessage); 
    204                         responseContent.setResultId(0); //not used at the moment 
     205                        responseContent.setResultId(0); // not used at the moment 
    205206                        responseContent.setHits(agent.getHits()); 
    206207                } 
    207208                return response; 
    208                  
    209 /* 
    210                 Integer numRes = myResult.getHits(); 
    211                  
    212                  
    213                 //at this stage record all parameters in request passed from ws into searchlogging DB 
    214                 //get sql insert statement based on input args           
    215                 String sqlInsertStmnt = recordSearchParamsToLog(doSearch.getDoSearch(), numRes, thisSessionID); 
    216                  
    217                 logger.info("Tracking DB insert stmnt: " + sqlInsertStmnt); 
    218                  
    219                  
    220                 //execute statement to search logging database 
    221                 try { 
    222                         if (DBProperties.updateSearchParamLoggingDb(sqlInsertStmnt)) {                   
    223                                 logger.info("Have successfully updated search parameter logging database!");                     
    224                         } else { 
    225                                 logger.warn("Could not update search logging database!"); 
    226                         } 
    227                 } catch (DiscoveryDBException E) { 
    228                         logger.warn("Could not connect to and update search logging database!"); 
    229                 }                                        
    230                 logger.info("Search completed"); 
    231  
    232         if (myResult != null) { 
    233                 logger.info("Checking results..."); 
    234                 responseContent.setStatus(myResult.getStatus()); 
    235                 responseContent.setStatusMessage(myResult.getStatusMessage()); 
    236                 responseContent.setResultId(myResult.getResultId()); 
    237                 if (myResult.getStatus()) {                      
    238                         responseContent.setHits(myResult.getHits()); 
    239                         Vector summaryDocuments = myResult.getDocuments(); 
    240  
    241                         if (summaryDocuments != null) { 
    242                                 logger.info("Search returned some matching documents"); 
    243                                 Documents responseDocuments = responseContent.addNewDocuments(); 
    244                                 for (Iterator i = summaryDocuments.iterator(); i.hasNext();) { 
    245                                         Hashtable document = (Hashtable) i.next(); 
    246                                         //responseDocuments.addDocument((String) document.get("name")); 
    247                                         responseDocuments.addDocumentId(""); 
    248                                 } 
    249  
    250                                 logger.info("Adding found documents to response"); 
    251                                 responseContent.setDocuments(responseDocuments); 
    252                         } else { 
    253                                 logger.info("null data set returned from search - this may indicate a problem"); 
    254                         } 
    255                 } else // unsuccessful search 
    256                 { 
    257                         logger.warn("Search status was unsuccessful - this may indicate a problem"); 
    258                         responseContent.setHits(0); 
    259                 } 
    260         } else { 
    261                 logger.warn("null data set returned from search - this may indicate a problem"); 
     209 
     210                /* 
     211                 * Integer numRes = myResult.getHits(); 
     212                 *  
     213                 *  
     214                 * //at this stage record all parameters in request passed from ws into 
     215                 * searchlogging DB //get sql insert statement based on input args 
     216                 * String sqlInsertStmnt = 
     217                 * recordSearchParamsToLog(doSearch.getDoSearchSummary(), numRes, 
     218                 * thisSessionID); 
     219                 *  
     220                 * logger.info("Tracking DB insert stmnt: " + sqlInsertStmnt); 
     221                 *  
     222                 *  
     223                 * //execute statement to search logging database try { if 
     224                 * (DBProperties.updateSearchParamLoggingDb(sqlInsertStmnt)) { 
     225                 * logger.info 
     226                 * ("Have successfully updated search parameter logging database!"); } 
     227                 * else { logger.warn("Could not update search logging database!"); } } 
     228                 * catch (DiscoveryDBException E) { 
     229                 * logger.warn("Could not connect to and update search logging database!" 
     230                 * ); } logger.info("Search completed"); 
     231                 *  
     232                 * if (myResult != null) { logger.info("Checking results..."); 
     233                 * responseContent.setStatus(myResult.getStatus()); 
     234                 * responseContent.setStatusMessage(myResult.getStatusMessage()); 
     235                 * responseContent.setResultId(myResult.getResultId()); if 
     236                 * (myResult.getStatus()) { responseContent.setHits(myResult.getHits()); 
     237                 * Vector summaryDocuments = myResult.getDocumeSummarynts(); 
     238                 *  
     239                 * if (summaryDocuments != null) { 
     240                 * logger.info("Search returned some matching documents"); Documents 
     241                 * responseDocuments = responseContent.addNewDocuments(); for (Iterator 
     242                 * i = summaryDocuments.iterator(); i.hasNext();) { Hashtable document = 
     243                 * (Hashtable) i.next(); //responseDocuments.addDocument((String) 
     244                 * document.get("name")); responseDocuments.addDocumentId(""); } 
     245                 *  
     246                 * logger.info("Adding found documents to response"); 
     247                 * responseContent.setDocuments(responseDocuments); } else { 
     248                 * logger.info( 
     249                 * "null data set returned from search - this may indicate a problem"); 
     250                 * } } else // unsuccessful search {logger.warn( 
     251                 * "Search status was unsuccessful - this may indicate a problem"); 
     252                 * responseContent.setHits(0); } } else {logger.warn( 
     253                 * "null data set returned from search - this may indicate a problem"); 
     254                 * } 
     255                 *  
     256                 * logger.warn("doSearch() completed successfully"); 
     257                 *  
     258                 * return response; 
     259                 */ 
    262260        } 
    263261 
    264         logger.warn("doSearch() completed successfully"); 
    265  
    266         return response; 
    267         */ 
    268         } 
    269  
    270262        /** 
    271263         * Auto generated method signature 
     
    274266         */ 
    275267 
    276         public discoveryserviceapi.DoPresentReturnDocument doPresent( 
    277                         discoveryserviceapi.DoPresentDocument doPresent) { 
     268        public discoveryserviceapi.DoPresentReturnDocument doPresent(discoveryserviceapi.DoPresentDocument doPresent) { 
    278269                // TODO : fill this with the necessary business logic 
    279                 throw new java.lang.UnsupportedOperationException("Please implement " 
    280                                 + this.getClass().getName() + "#doPresent"); 
     270                throw new java.lang.UnsupportedOperationException("Please implement " + this.getClass().getName() 
     271                                + "#doPresent"); 
    281272        } 
    282273 
     
    289280         * @throws DiscoveryWSException 
    290281         */ 
    291         public discoveryserviceapi.GetListReturnDocument getList( 
    292                         discoveryserviceapi.GetListDocument request) { 
     282        public discoveryserviceapi.GetListReturnDocument getList(discoveryserviceapi.GetListDocument request) { 
    293283                logger.info("getList() invoked"); 
    294284                discoveryserviceapi.GetListReturnDocument response = discoveryserviceapi.GetListReturnDocument.Factory 
    295285                                .newInstance(); 
    296                 discoveryserviceapi.GetListReturnType responseContent = response 
    297                                 .addNewGetListReturn(); 
    298                 discoveryserviceapi.GetListReturnType.List list = responseContent 
    299                                 .addNewList(); 
     286                discoveryserviceapi.GetListReturnType responseContent = response.addNewGetListReturn(); 
     287                discoveryserviceapi.GetListReturnType.List list = responseContent.addNewList(); 
    300288 
    301289                // parse the request message 
     
    307295                        for (DiscoveryDictionary.TermTarget item : DiscoveryDictionary.TermTarget.values()) { 
    308296                                list.addListMember(item.fieldLabel()); 
    309                         }                        
     297                        } 
    310298                } else if (listName.equals("PresentFormatList")) { 
    311299                        list.addListMember(DC_PRESENTFORMAT); 
     
    318306                        } 
    319307                        /* 
    320                         list.addListMember(TEXTRELEVANCE_ORDERBYFIELD); 
    321                         list.addListMember(DATASETORDER_ORDERBYFIELD); 
    322                         list.addListMember(DATASETSTARTDATE_ORDERBYFIELD); 
    323                         list.addListMember(DATASETENDDATE_ORDERBYFIELD); 
    324                         list.addListMember(DATACEENTRE_ORDERBYFIELD); 
    325                         list.addListMember(DATASETRESULTSETPOPULARITY_ORDERBYFIELD); 
    326                         list.addListMember(PROXIMITY_ORDERBYFIELD); 
    327                         list.addListMember(PROXIMITYNEARMISS_ORDERBYFIELD); 
    328                         list.addListMember(DATASETUPDATEORDER_ORDERBYFIELD); 
    329                         list.addListMember(DATASETORDER_ORDERBYFIELD); 
    330                         list.addListMember(DISCOVERYINGESTDATE_ORDERBYFIELD); 
    331                         list.addListMember(MEDINTERMTARGET1_ORDERBYFIELD); 
    332                         */ 
     308                         * list.addListMember(TEXTRELEVANCE_ORDERBYFIELD); 
     309                         * list.addListMember(DATASETORDER_ORDERBYFIELD); 
     310                         * list.addListMember(DATASETSTARTDATE_ORDERBYFIELD); 
     311                         * list.addListMember(DATASETENDDATE_ORDERBYFIELD); 
     312                         * list.addListMember(DATACEENTRE_ORDERBYFIELD); 
     313                         * list.addListMember(DATASETRESULTSETPOPULARITY_ORDERBYFIELD); 
     314                         * list.addListMember(PROXIMITY_ORDERBYFIELD); 
     315                         * list.addListMember(PROXIMITYNEARMISS_ORDERBYFIELD); 
     316                         * list.addListMember(DATASETUPDATEORDER_ORDERBYFIELD); 
     317                         * list.addListMember(DATASETORDER_ORDERBYFIELD); 
     318                         * list.addListMember(DISCOVERYINGESTDATE_ORDERBYFIELD); 
     319                         * list.addListMember(MEDINTERMTARGET1_ORDERBYFIELD); 
     320                         */ 
    333321                } else if (listName.equals("ScopeList")) { 
    334322                        list.addListMember(MEDIN_SCOPE); 
     
    343331                        list.addListMember(EPSG4326_SPATIALREFERENCESYSTEM); 
    344332                } else if (listName.equals("DateRangeTargetList")) { 
    345                         list.addListMember(TEMPORALCOVERAGE_DATERANGETARGET); 
    346                         list.addListMember(LASTREVISIONDATE_DATERANGETARGET); 
    347                         list.addListMember(DISCOVERYINGESTDATE_DATERANGETARGET); 
     333                        for (DiscoveryDictionary.DateRangeTarget item : DiscoveryDictionary.DateRangeTarget.values()) { 
     334                                list.addListMember(item.fieldLabel()); 
     335                        } 
    348336                } else if (listName.equals("TemporalOperatorList")) { 
    349                         list.addListMember(EQUALS_TEMPORALOPERATOR); 
    350                         list.addListMember(DOESNOTEQUAL_TEMPORALOPERATOR); 
    351                         list.addListMember(ONORBEFORE_TEMPORALOPERATOR); 
    352                         list.addListMember(ONORAFTER_TEMPORALOPERATOR); 
    353                         list.addListMember(BEFORE_TEMPORALOPERATOR); 
    354                         list.addListMember(AFTER_TEMPORALOPERATOR); 
     337                        for (DiscoveryDictionary.TemporalOperator item : DiscoveryDictionary.TemporalOperator.values()) { 
     338                                list.addListMember(item.fieldLabel()); 
     339                        } 
    355340                } else if (listName.equals("MetadataFormatList")) { 
    356341                        list.addListMember(DC_METADATAFORMAT); 
     
    359344                        list.addListMember(ISO19115_METADATAFORMAT); 
    360345                } else if (listName.equals("RecordDetailList")) { 
    361                         for (DiscoveryDictionary.RecordDetailList item : DiscoveryDictionary.RecordDetailList.values()) { 
     346                        for (DiscoveryDictionary.RecordDetail item : DiscoveryDictionary.RecordDetail.values()) { 
    362347                                list.addListMember(item.fieldLabel()); 
    363348                        } 
    364                         /* 
    365                         list.addListMember(ID_RECORDDETAIL); 
    366                         list.addListMember(BRIEF_RECORDDETAIL); 
    367                         list.addListMember(SUMMARY_RECORDDETAIL);*/ 
    368                         } else { 
     349                } else { 
    369350                        logger.warn(INVALID_LIST_NAME_MESSAGE); 
    370                         //throw new DiscoveryWSException(INVALID_LIST_NAME_MESSAGE); 
     351                        // throw new DiscoveryWSException(INVALID_LIST_NAME_MESSAGE); 
    371352                } 
    372353 
     
    376357 
    377358        /** 
    378          * Prepare an INSERT sql statement taking variables from available discoveryserviceapi.SearchType 
    379          *  
    380          * @param requestContent - discoveryserviceapi.SearchType 
    381          *          
     359         * Prepare an INSERT sql statement taking variables from available 
     360         * discoveryserviceapi.SearchType 
     361         *  
     362         * @param requestContent 
     363         *            - discoveryserviceapi.SearchType 
     364         *  
    382365         * @return String : sql insert statement 
    383          *//* 
    384         public static String recordSearchParamsToLog(discoveryserviceapi.SearchType requestContentToLog, Integer numHits, String thisSessionID) { 
     366         */ 
     367        /* 
     368         * public static String 
     369         * recordSearchParamsToLog(discoveryserviceapi.SearchType 
     370         * requestContentToLog, Integer numHits, String thisSessionID) { 
     371         *  
     372         * //extract from request content 
     373         * logger.info("Constructing search DB logger sql update from requestContent" 
     374         * ); 
     375         *  
     376         * //TODO: get originator IP and originating PORTAL IP 
     377         *  
     378         * //concatenate all scope into single comma separated string String 
     379         * scopeString = ""; if (requestContentToLog.sizeOfScopeArray() > 0) { for 
     380         * (int i = 0; i < requestContentToLog.sizeOfScopeArray(); i++) { if (i == 
     381         * 0){ scopeString = (requestContentToLog.getScopeArray(i).toString()); } 
     382         * elsenull; 
     383         *  
     384         * myResult = { scopeString = scopeString + "," + 
     385         * (requestContentToLog.getScopeArray(i).toString()); } } } else { 
     386         * scopeString = "null"; } 
     387         *  
     388         * //check whether text term, spatial and temporal operators are available.. 
     389         * String searchTxtTerm = ""; if 
     390         * (Utilities.isStringDefined(requestContentToLog.getTerm())){ searchTxtTerm 
     391         * = "'" + requestContentToLog.getTerm() + "'"; } else { searchTxtTerm = 
     392         * "null"; } 
     393         *  
     394         * String dateRangeStart = ""; String dateRangeEnd = ""; if 
     395         * (requestContentToLog.isSetDateRange()) { dateRangeStart = "'" + 
     396         * requestContentToLog.getDateRange().getDateRangeStart().toString() + "'"; 
     397         * dateRangeEnd = "'" + 
     398         * requestContentToLog.getDateRange().getDateRangeEnd().toString() + "'"; } 
     399         * else { dateRangeStart = "null"; dateRangeEnd = "null"; } 
     400         *  
     401         * String boundingBoxAsPolyString = ""; if 
     402         * (requestContentToLog.isSetBoundingBox()) { boundingBoxAsPolyString = "'" 
     403         * + requestContentToLog.getBoundingBox().getLimitWest() + " " + 
     404         * requestContentToLog.getBoundingBox().getLimitNorth() + "," + 
     405         * requestContentToLog.getBoundingBox().getLimitEast() + " " + 
     406         * requestContentToLog.getBoundingBox().getLimitNorth() + "," + 
     407         * requestContentToLog.getBoundingBox().getLimitEast() + " " + 
     408         * requestContentToLog.getBoundingBox().getLimitSouth() + "," + 
     409         * requestContentToLog.getBoundingBox().getLimitWest() + " " + 
     410         * requestContentToLog.getBoundingBox().getLimitSouth() + "," + 
     411         * requestContentToLog.getBoundingBox().getLimitWest() + " " + 
     412         * requestContentToLog.getBoundingBox().getLimitNorth() + "'"; 
     413         *  
     414         * } else { boundingBoxAsPolyString = "null"; } 
     415         *  
     416         * String statementStringBuild = 
     417         * "insert into discoverySearchLogging(session_ID,search_term,start_time,end_time,date_of_search,scope,originator_IP,portal_IP,geographicExtent_As_Text, number_results_returned) " 
     418         * + "values (" + "'" + thisSessionID + "'" + "," + searchTxtTerm + "," + 
     419         * dateRangeStart + "," + dateRangeEnd + "," + "'" + Utilities.nowDateTime() 
     420         * + "'" + "," + "'" + scopeString + "'" + "," + "'originatorIP'" + "," + 
     421         * "'portalIP'" + "," + boundingBoxAsPolyString + "," + "'" + 
     422         * numHits.toString() + "'" + ");"; 
     423         *  
     424         * return statementStringBuild; 
     425         *  
     426         * return ""; } 
     427         */ 
     428 
     429        private void processResult(List<OriginalDocument> results, Documents documents, SearchType criteria) { 
     430                if (results != null && results.size() == 0) 
     431                        return; 
    385432                 
    386                 //extract from request content 
    387                 logger.info("Constructing search DB logger sql update from requestContent"); 
    388                  
    389                 //TODO: get originator IP and originating PORTAL IP              
    390                  
    391                 //concatenate all scope into single comma separated string 
    392                 String scopeString = ""; 
    393                 if (requestContentToLog.sizeOfScopeArray() > 0) { 
    394                         for (int i = 0; i < requestContentToLog.sizeOfScopeArray(); i++) { 
    395                                 if (i == 0){ 
    396                                         scopeString = (requestContentToLog.getScopeArray(i).toString()); 
    397                                 } elsenull; 
    398  
    399                                 myResult = { 
    400                                         scopeString = scopeString + "," + (requestContentToLog.getScopeArray(i).toString()); 
    401                                 }                                
    402                         } 
    403                 } else { 
    404                         scopeString = "null"; 
    405                 } 
    406                  
    407                 //check whether text term, spatial and temporal operators are available.. 
    408                 String searchTxtTerm = ""; 
    409                 if (Utilities.isStringDefined(requestContentToLog.getTerm())){ 
    410                         searchTxtTerm = "'" + requestContentToLog.getTerm() + "'"; 
    411                 } else { 
    412                         searchTxtTerm = "null"; 
    413                 } 
    414                  
    415                 String dateRangeStart = ""; 
    416                 String dateRangeEnd = "";                
    417                 if (requestContentToLog.isSetDateRange()) { 
    418                         dateRangeStart = "'" + requestContentToLog.getDateRange().getDateRangeStart().toString() + "'"; 
    419                         dateRangeEnd = "'" + requestContentToLog.getDateRange().getDateRangeEnd().toString() + "'"; 
    420                 } else { 
    421                         dateRangeStart = "null"; 
    422                         dateRangeEnd = "null"; 
    423                 } 
    424                  
    425                 String boundingBoxAsPolyString = ""; 
    426                 if (requestContentToLog.isSetBoundingBox()) { 
    427                         boundingBoxAsPolyString = "'" + requestContentToLog.getBoundingBox().getLimitWest() + " " + requestContentToLog.getBoundingBox().getLimitNorth() + "," +   
    428                         requestContentToLog.getBoundingBox().getLimitEast() + " " + requestContentToLog.getBoundingBox().getLimitNorth() + "," + 
    429                         requestContentToLog.getBoundingBox().getLimitEast() + " " + requestContentToLog.getBoundingBox().getLimitSouth() + "," +  
    430                         requestContentToLog.getBoundingBox().getLimitWest() + " " + requestContentToLog.getBoundingBox().getLimitSouth() + "," +  
    431                         requestContentToLog.getBoundingBox().getLimitWest() + " " + requestContentToLog.getBoundingBox().getLimitNorth() + "'";  
    432                                                          
    433                 } else { 
    434                         boundingBoxAsPolyString = "null"; 
    435                 }                        
     433                DiscoveryDictionary.RecordDetail type = DiscoveryDictionary.getRecordDetails(criteria.getRecordDetail()); 
     434 
     435                /** all the IFs should be revisited */ 
     436                for (OriginalDocument result : results) { 
     437 
     438                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentId)) { 
     439                                XmlString idType = documents.addNewDocumentId(); 
     440                                idType.setStringValue(result.getOriginalDocumentFilename()); 
     441                                continue; 
     442                        } 
     443 
     444                        /* -- Please note that the following IF do not own a continue  
     445                         * statement in order to execute the final 'fillOrderedField' -- */ 
     446                        Object documentType = null; 
     447                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) { 
     448                                ReturnFullType fullType = documents.addNewDocumentFull();                                
     449                                fullType.setDocumentId(result.getOriginalDocumentFilename()); 
     450                                fullType.setTitle(result.getDatasetName()); 
     451                                fullType.setDocument(result.getOriginalDocument()); 
     452                                fullType.setAbstract(result.getDatasetAbstract()); 
     453                                documentType = fullType; 
     454                        } 
     455                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentSummary)) { 
     456                                ReturnSummaryType summaryType = documents.addNewDocumentSummary(); 
     457                                summaryType.setDocumentId(result.getOriginalDocumentFilename()); 
     458                                summaryType.setTitle(result.getDatasetName()); 
     459                                summaryType.setAbstract(result.getDatasetAbstract()); 
     460                                documentType = summaryType; 
     461                        } 
     462                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentBrief)) { 
     463                                ReturnBriefType briefType = documents.addNewDocumentBrief(); 
     464                                briefType.setDocumentId(result.getOriginalDocumentFilename()); 
     465                                briefType.setTitle(result.getDatasetName()); 
     466                                documentType = briefType; 
     467                        } 
     468                        fillOrderedFieldArray(documentType, criteria.getOrderByArray(), result); 
     469                } 
     470        } 
    436471         
    437                 String statementStringBuild = "insert into discoverySearchLogging(session_ID,search_term,start_time,end_time,date_of_search,scope,originator_IP,portal_IP,geographicExtent_As_Text, number_results_returned) " 
    438                         + "values (" 
    439                         + "'" + thisSessionID + "'" 
    440                         + "," 
    441                         + searchTxtTerm 
    442                         + "," 
    443                         + dateRangeStart 
    444                         + "," 
    445                         + dateRangeEnd 
    446                         + "," 
    447                         + "'" + Utilities.nowDateTime() + "'" 
    448                         + "," 
    449                         + "'" + scopeString + "'" 
    450                         + "," 
    451                         + "'originatorIP'" 
    452                         + "," 
    453                         + "'portalIP'" 
    454                         + "," 
    455                         + boundingBoxAsPolyString 
    456                         + "," 
    457                         + "'" + numHits.toString() + "'" 
    458                         + ");";  
    459                  
    460                 return statementStringBuild; 
    461                  
    462                 return ""; 
    463         }               */ 
     472        /** 
     473         * Fills the <code>OrderedFieldArray[]</code> in the given <code>documentType</code> with  
     474         * the proper values from the documents retrieved after the query. 
     475         * Obviously if the user request included the request to sort by some field.  
     476         **/ 
     477        private void fillOrderedFieldArray(Object documentType, OrderByType[] orders, OriginalDocument result) { 
     478                for (OrderByType orderType : orders) { 
     479                        OrderByField order = DiscoveryDictionary.getOrderByField(orderType.getOrderByField()); 
     480                        if (order == null) 
     481                                continue; 
     482                        OrderingMetricType newOMT = getNewOMT(documentType); 
     483                        newOMT.setMetricName(order.fieldLabel()); 
     484                        String value = "DataError"; 
     485                        NdgMessage msg = new NdgMessage("invocation.error", new Object[] { "Field.get(result)" });                       
     486                        try { 
     487                                PropertyDescriptor field = DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()); 
     488                                value = field.getReadMethod().invoke(result, new Object[0]).toString(); 
     489                                newOMT.setMetricValue(value); 
     490                        } catch (IllegalArgumentException e) { 
     491                                logger.error(msg, e); 
     492                        } catch (IllegalAccessException e) { 
     493                                logger.error(msg, e); 
     494                        } catch (InvocationTargetException e) { 
     495                                logger.error(msg, e); 
     496                        } 
     497                } 
     498        } 
    464499         
    465         private void processResult(Set<MEDINSearchResult> results,  
    466                         Documents documents, DiscoveryDictionary.RecordDetailList type){ 
    467                 /** all the IFs should be revisited */ 
    468                 for(MEDINSearchResult result : results) { 
    469                          
    470                         if (type.equals(DiscoveryDictionary.RecordDetailList.DocumentId)) { 
    471                                 XmlString idType = documents.addNewDocumentId(); 
    472                                 idType.setStringValue(result.getOrigDocFileName()); 
    473                                 continue; 
    474                         } 
    475                         if (type.equals(DiscoveryDictionary.RecordDetailList.DocumentFull)) { 
    476                                 ReturnFullType fullType = documents.addNewDocumentFull(); 
    477                                 fullType.setDocumentId(result.getOrigDocFileName()); 
    478                                 fullType.setTitle(result.getDatasetName()); 
    479                                 fullType.setDocument(result.getDocument()); 
    480                                 fullType.setAbstract(result.getDocumentAbstract()); 
    481                                 continue; 
    482                         } 
    483                         if (type.equals(DiscoveryDictionary.RecordDetailList.DocumentSummary)) { 
    484                                 ReturnSummaryType summaryType = documents.addNewDocumentSummary(); 
    485                                 summaryType.setDocumentId(result.getOrigDocFileName()); 
    486                                 summaryType.setTitle(result.getDatasetName()); 
    487                                 summaryType.setAbstract(result.getDocumentAbstract()); 
    488                                 continue; 
    489                         } 
    490                         if (type.equals(DiscoveryDictionary.RecordDetailList.DocumentSummary)) { 
    491                                 ReturnBriefType briefType = documents.addNewDocumentBrief(); 
    492                                 briefType.setDocumentId(result.getOrigDocFileName()); 
    493                                 briefType.setTitle(result.getDatasetName());     
    494                                 continue; 
    495                         }        
    496                 } 
     500        /** 
     501         * Creates in the given <code>documentType</code>, and returns it,  
     502         * a new {@link OrderingMetricType} 
     503         **/     
     504        private OrderingMetricType getNewOMT(Object documentType){ 
     505                OrderingMetricType ret = null; 
     506                if (ReturnFullType.class.isAssignableFrom(documentType.getClass())){ 
     507                        ReturnFullType tmp = (ReturnFullType)documentType; 
     508                        ret = tmp.addNewOrderedField(); 
     509                } 
     510                if (ReturnBriefType.class.isAssignableFrom(documentType.getClass())){ 
     511                        ReturnBriefType tmp = (ReturnBriefType)documentType; 
     512                        ret = tmp.addNewOrderedField(); 
     513                } 
     514                if (ReturnSummaryType.class.isAssignableFrom(documentType.getClass())){ 
     515                        ReturnSummaryType tmp = (ReturnSummaryType)documentType; 
     516                        ret = tmp.addNewOrderedField(); 
     517                } 
     518                return ret; 
    497519        }        
    498520} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/medin/DiscoveryDictionary.java

    r6465 r6504  
    11package ndg.services.discovery.medin; 
    22 
    3 public interface DiscoveryDictionary { 
     3import java.beans.BeanInfo; 
     4import java.beans.IntrospectionException; 
     5import java.beans.Introspector; 
     6import java.beans.PropertyDescriptor; 
     7import java.lang.reflect.InvocationTargetException; 
     8 
     9import ndg.common.NdgMessage; 
     10import ndg.common.exception.NdgException; 
     11import ndg.services.jpa.OriginalDocument; 
     12 
     13 
     14public final class DiscoveryDictionary { 
    415 
    516        /** The name of the global configuration file*/ 
     
    1526        public final static String JDBC_PSW = "jdbc.password"; 
    1627         
    17         /** RecordDetailList options */ 
    18         public final static String RECORD_DETAIL_FULL = "Full"; 
    19         public final static String RECORD_DETAIL_BRIEF = "Brief"; 
    20         public final static String RECORD_DETAIL_SUMMARY = "Summary";    
    21          
    22         enum TermTarget { 
     28        public static enum TermTarget { 
    2329                FullText("document_ts_vector", "FullText"), 
    2430                Author("authors_ts_vector", "Author"), 
     
    4046        }        
    4147         
    42         enum OrderByField { 
    43                 DatasetStartDate("dataset_start_date_nom", "DatasetStartDate"), 
    44                 DatasetEndDate("dataset_end_date_nom", "DatasetEndDate"),        
    45                 DataCenter("datacentre_name", "DataCenter"), 
    46                 DatasetUpdate("update_date", "DatasetUpdateOrder"), 
    47                 DiscoveryIngestDate("create_date", "DiscoveryIngestDate"); 
    48                  
    49                 private final String fieldName; 
    50                 private final String fieldLabel; 
    51                 OrderByField(String fieldName, String fieldLabel) { 
    52                         this.fieldName = fieldName; 
    53                         this.fieldLabel = fieldLabel; 
    54                 } 
    55                 public final String fieldName() { 
    56                         return fieldName; 
    57                 } 
    58                 public final String fieldLabel() { 
    59                         return fieldLabel; 
    60                 }                
    61         } 
    62          
    63         enum OrderDirection { 
     48        public static enum OrderByField { 
     49                DatasetStartDate("dataset_start_date_nom", "DatasetStartDate", "datasetStartDateNom"), 
     50                DatasetEndDate("dataset_end_date_nom", "DatasetEndDate", "datasetEndDateNom"),   
     51                DataCenter("datacentre_name", "DataCenter", "datacentreName"), 
     52                DatasetUpdate("update_date", "DatasetUpdateOrder", "updateDate"), 
     53                DiscoveryIngestDate("create_date", "DiscoveryIngestDate", "createDate"); 
     54                 
     55                private final String fieldName; 
     56                private final String fieldLabel; 
     57                private final String odField; 
     58                OrderByField(String fieldName, String fieldLabel, String odField) { 
     59                        this.fieldName = fieldName; 
     60                        this.fieldLabel = fieldLabel; 
     61                        this.odField = odField; 
     62                } 
     63                public final String fieldName() { 
     64                        return fieldName; 
     65                } 
     66                public final String fieldLabel() { 
     67                        return fieldLabel; 
     68                } 
     69                public final String getOdField() { 
     70                        return odField; 
     71                }                
     72 
     73        } 
     74         
     75        public static enum OrderDirection { 
    6476                DESC("DESC", "descending"), 
    6577                ASC("ASC", "ascending");                 
     
    7991        } 
    8092         
    81         enum RecordDetailList { 
     93        public static enum RecordDetail { 
    8294                DocumentId("DocumentId", "DocumentId"), 
    8395                DocumentBrief("Brief", "DocumentBrief"), 
     
    8799                private final String fieldName; 
    88100                private final String fieldLabel; 
    89                 RecordDetailList(String fieldName, String fieldLabel) { 
    90                         this.fieldName = fieldName; 
    91                         this.fieldLabel = fieldLabel; 
    92                 } 
    93                 public final String fieldName() { 
    94                         return fieldName; 
    95                 } 
    96                 public final String fieldLabel() { 
    97                         return fieldLabel; 
    98                 }                
     101                RecordDetail(String fieldName, String fieldLabel) { 
     102                        this.fieldName = fieldName; 
     103                        this.fieldLabel = fieldLabel; 
     104                } 
     105                public final String fieldName() { 
     106                        return fieldName; 
     107                } 
     108                public final String fieldLabel() { 
     109                        return fieldLabel; 
     110                }                
     111        } 
     112         
     113        public static enum DateRangeTarget { 
     114                TemporalCoverage("TemporalCoverage", "Temporal Coverage"), 
     115                LastRevisionDate("dataset_metadata_update_date", "Last Revision Date"), 
     116                DiscoveryIngestDate("update_date", "Discovery Ingest Date");             
     117                 
     118                private final String fieldName; 
     119                private final String fieldLabel; 
     120                DateRangeTarget(String fieldName, String fieldLabel) { 
     121                        this.fieldName = fieldName; 
     122                        this.fieldLabel = fieldLabel; 
     123                } 
     124                public final String fieldName() { 
     125                        return fieldName; 
     126                } 
     127                public final String fieldLabel() { 
     128                        return fieldLabel; 
     129                }                
     130        } 
     131 
     132        public static enum TemporalOperator { 
     133                Equals("=", "Equals"), 
     134                DoesNotEqual("<>", "Does Not Equal"), 
     135                OnOrBefore("<=", "On Or Before"), 
     136                OnOrAfter(">=", "On Or After"), 
     137                Before("<", "Before"), 
     138                After(">", "After");             
     139                 
     140                private final String fieldName; 
     141                private final String fieldLabel; 
     142                TemporalOperator(String fieldName, String fieldLabel) { 
     143                        this.fieldName = fieldName; 
     144                        this.fieldLabel = fieldLabel; 
     145                } 
     146                public final String fieldName() { 
     147                        return fieldName; 
     148                } 
     149                public final String fieldLabel() { 
     150                        return fieldLabel; 
     151                }                
     152        } 
     153         
     154        public static enum Scope { 
     155                MDIP("MDIP", "Marine Data Information Partnership (organisation now renamed MEDIN) "), 
     156                NERC_DDC("NERC_DDC", "NERC Designated Data Centres"), 
     157                NERC("NERC", "NERC (General)"), 
     158                DPPP("DPPP", "Data Portals Project Provider ");          
     159                 
     160                private final String fieldName; 
     161                private final String fieldLabel; 
     162                Scope(String fieldName, String fieldLabel) { 
     163                        this.fieldName = fieldName; 
     164                        this.fieldLabel = fieldLabel; 
     165                } 
     166                public final String fieldName() { 
     167                        return fieldName; 
     168                } 
     169                public final String fieldLabel() { 
     170                        return fieldLabel; 
     171                }                
     172        }        
     173         
     174        /** 
     175         * Returns the {@link TermTarget} proper element 
     176         * for the given parameter. In the paramenter is <code>null</code> or 
     177         * not found the default value {@link TermTarget#FullText}} 
     178         * is returned 
     179         * @param label the name of the required termType. 
     180         * @return the proper {@link TermTarget} or the default value  
     181         * */ 
     182        public static TermTarget getTermType(String label) { 
     183                TermTarget type = TermTarget.FullText; 
     184                if (label != null) { 
     185                        for (TermTarget item : TermTarget.values()) { 
     186                                if(label.trim().equals(item.fieldLabel())) {file:///home/users/mnagni/workspace/MARINDiscoveryService/target/MedinDiscoveryService-0.0.1-SNAPSHOT.aar 
     187                                        type = item; 
     188                                        break; 
     189                                } 
     190                        }        
     191                } 
     192                return type; 
     193        } 
     194 
     195        /** 
     196         * Returns the {@link RecordDetail} proper element 
     197         * for the given parameter. In the paramenter is <code>null</code> or 
     198         * not found the default value {@link RecordDetail#DocumentId}} 
     199         * is returned 
     200         * @param label the name of the required detailType. 
     201         * @return the proper {@link RecordDetail} or the default value  
     202         * */ 
     203        public static RecordDetail getRecordDetails(String label){ 
     204                RecordDetail type = RecordDetail.DocumentId; 
     205                if (label != null) { 
     206                        for (RecordDetail item : RecordDetail.values()) { 
     207                                if(label.trim().equals(item.fieldLabel())) { 
     208                                        type = item; 
     209                                        break; 
     210                                } 
     211                        }        
     212                } 
     213                return type; 
     214        }        
     215         
     216        /** 
     217         * Returns the {@link DateRangeTarget} proper element 
     218         * for the given parameter. In the paramenter is <code>null</code> or 
     219         * not found the default value {@link DateRangeTarget#TemporalCoverage}} 
     220         * is returned 
     221         * @param label the name of the required termType. 
     222         * @return the proper {@link DateRangeTarget} or the default value  
     223         * */ 
     224        public static DateRangeTarget getDateRangeTarget(String label) { 
     225                DateRangeTarget type = DateRangeTarget.TemporalCoverage; 
     226                if (label != null) { 
     227                        for (DateRangeTarget item : DateRangeTarget.values()) { 
     228                                if(label.trim().equals(item.fieldLabel())) { 
     229                                        type = item; 
     230                                        break; 
     231                                } 
     232                        }        
     233                } 
     234                return type; 
     235        } 
     236         
     237        /** 
     238         * Returns the {@link TemporalOperator} proper element 
     239         * for the given parameter. In the paramenter is <code>null</code> or 
     240         * not found the default value {@link TemporalOperator#OnOrAfter}} 
     241         * is returned 
     242         * @param label the name of the required termType. 
     243         * @return the proper {@link DateRangeTarget} or the default value  
     244         * */ 
     245        public static TemporalOperator getTemporalOperator(String label) { 
     246                TemporalOperator type = TemporalOperator.OnOrAfter; 
     247                if (label != null) { 
     248                        for (TemporalOperator item : TemporalOperator.values()) { 
     249                                if(label.trim().equals(item.fieldLabel())) { 
     250                                        type = item; 
     251                                        break; 
     252                                } 
     253                        }        
     254                } 
     255                return type; 
     256        } 
     257         
     258        public static OrderByField getOrderByField(String fieldName){ 
     259                OrderByField ret = null; 
     260                for (OrderByField orderField : OrderByField.values()) { 
     261                        if (orderField.fieldLabel().equals(fieldName)) { 
     262                                ret = orderField; 
     263                                break; 
     264                        } 
     265                } 
     266                return ret;              
     267        } 
     268         
     269        public static OrderDirection getOrderDirection(String fieldName){ 
     270                OrderDirection ret = OrderDirection.DESC; 
     271                for (OrderDirection orderField : OrderDirection.values()) { 
     272                        if (orderField.fieldLabel().equals(fieldName)) { 
     273                                ret = orderField; 
     274                                break; 
     275                        } 
     276                } 
     277                return ret;              
     278        } 
     279         
     280        public static DiscoveryDictionary.Scope getScope(String fieldName){ 
     281                Scope ret = null; 
     282                for (Scope orderField : Scope.values()) { 
     283                        if (orderField.fieldLabel().equals(fieldName)) { 
     284                                ret = orderField; 
     285                                break; 
     286                        } 
     287                } 
     288                return ret;              
     289        } 
     290         
     291        private static PropertyDescriptor[] pd = null; 
     292        public static PropertyDescriptor getOriginalDocumentProperty(String fieldName){ 
     293                if (pd == null) { 
     294                        try { 
     295                                BeanInfo info = Introspector.getBeanInfo(OriginalDocument.class); 
     296                                pd = info.getPropertyDescriptors();                              
     297                        } catch (IntrospectionException e) { 
     298                                // TODO Auto-generated catch block 
     299                                e.printStackTrace(); 
     300                        }        
     301                } 
     302                PropertyDescriptor ret = null; 
     303                for (PropertyDescriptor item : pd) { 
     304                        if (item.getName().equals(fieldName)){ 
     305                                ret = item; 
     306                                break; 
     307                        }                                
     308                } 
     309                return ret; 
    99310        } 
    100311} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/medin/Utilities.java

    r6469 r6504  
    77import java.util.regex.Matcher; 
    88import java.util.regex.Pattern; 
    9  
    10 import ndg.services.discovery.medin.DiscoveryDictionary.RecordDetailList; 
    119 
    1210import org.apache.log4j.Logger; 
     
    248246                return searchTerm; 
    249247        } 
    250          
    251         /** 
    252          * Returns the {@link DiscoveryDictionary.RecordDetailList} proper element 
    253          * for the given parameter. In the paramenter is <code>null</code> or 
    254          * not found the default value {@link DiscoveryDictionary.RecordDetailList#DocumentId}} 
    255          * is returned 
    256          * @param detailType the name of the required detailType. 
    257          * @return the proper {@link DiscoveryDictionary.RecordDetailList} or the default value  
    258          * */ 
    259         public static RecordDetailList getRecordDetails(String detailType){ 
    260                 DiscoveryDictionary.RecordDetailList type = DiscoveryDictionary.RecordDetailList.DocumentId; 
    261                 if (detailType != null) { 
    262                         for (DiscoveryDictionary.RecordDetailList item : DiscoveryDictionary.RecordDetailList.values()) { 
    263                                 if(detailType.trim().equals(item.fieldLabel())) { 
    264                                         type = item; 
    265                                         break; 
    266                                 } 
    267                         }        
    268                 } 
    269                 return type; 
    270         } 
    271248} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/SearchAgent.java

    r6469 r6504  
    11package ndg.services.discovery.model; 
    22 
     3import java.beans.PropertyDescriptor; 
     4import java.lang.reflect.Field; 
     5import java.lang.reflect.InvocationTargetException; 
     6import java.security.Timestamp; 
    37import java.sql.Connection; 
    48import java.sql.ResultSet; 
     
    610import java.sql.Statement; 
    711import java.util.ArrayList; 
    8 import java.util.HashSet; 
    912import java.util.Iterator; 
    1013import java.util.List; 
    11 import java.util.Set; 
    1214 
    1315import ndg.common.MessageFormatter; 
     
    1517import ndg.common.exception.NdgSQLException; 
    1618import ndg.common.exception.ResourceNotAvailable; 
    17 import ndg.services.discovery.exception.DiscoveryWSException; 
    1819import ndg.services.discovery.medin.DiscoveryBasic; 
    1920import ndg.services.discovery.medin.DiscoveryDictionary; 
    20 import ndg.services.discovery.medin.Utilities; 
     21import ndg.services.discovery.medin.DiscoveryDictionary.OrderByField; 
     22import ndg.services.discovery.medin.DiscoveryDictionary.Scope; 
     23import ndg.services.discovery.medin.DiscoveryDictionary.TemporalOperator; 
     24import ndg.services.jpa.OriginalDocument; 
    2125 
    2226import org.apache.log4j.Logger; 
    2327 
     28import discoveryserviceapi.DateRangeType; 
     29import discoveryserviceapi.DateValueType; 
    2430import discoveryserviceapi.OrderByType; 
    2531import discoveryserviceapi.SearchType; 
     32import discoveryserviceapi.TemporalType; 
    2633import discoveryserviceapi.TermSearchType; 
    2734import discoveryserviceapi.SearchType.SearchCriteria; 
     
    3946        public static final String PARAMETER_TERM_TYPE = "parameter"; 
    4047 
    41         private static Logger logger = Logger 
    42                         .getLogger(SearchAgent.class.getName()); 
     48        private static Logger logger = Logger.getLogger(SearchAgent.class.getName()); 
    4349 
    4450        // how many results to display in result set 
     
    6874         *             if cannot access to the database 
    6975         */ 
    70         public Set<MEDINSearchResult> doSearch() throws NdgSQLException, 
    71                         ResourceNotAvailable { 
     76        public List<OriginalDocument> doSearch() throws NdgSQLException, ResourceNotAvailable { 
    7277                SearchCriteria criteria = searchType.getSearchCriteria(); 
    7378                Connection conn = DiscoveryBasic.getInstance().getConnection(); 
    74                 Set<MEDINSearchResult> searchResult = null; 
     79                List<OriginalDocument> searchResult = null; 
    7580                boolean commit = false; 
    7681                try { 
    7782                        conn.setAutoCommit(false); 
    78                         searchResult = searchDocuments(conn, criteria.getTermSearchArray()); 
     83                        searchResult = searchDocuments(conn, criteria); 
    7984                        commit = true; 
    8085                } catch (SQLException e) { 
     
    9499         *                available 
    95100         **/ 
    96         private Set<MEDINSearchResult> searchDocuments(Connection conn, 
    97                         TermSearchType[] termSearchTypes) throws NdgSQLException { 
    98                 Set<MEDINSearchResult> res = new HashSet<MEDINSearchResult>(); 
    99                 Set<String> searchResult = new HashSet<String>(); 
    100                 for (TermSearchType termType : termSearchTypes) { 
    101                         Set<String> tempRes = executeSearch(conn, assembleSearch(termType)); 
    102                         if (tempRes != null) 
    103                                 searchResult.addAll(tempRes); 
    104                 } 
    105                 hits = searchResult.size(); 
    106                 res = retrieveDocuments(conn, searchResult); 
     101        private List<OriginalDocument> searchDocuments(Connection conn, SearchCriteria criteria) throws NdgSQLException { 
     102                List<OriginalDocument> res = new ArrayList<OriginalDocument>(); 
     103                List<String> toFilter = executeSearch(conn, assembleSearch(criteria)); 
     104 
     105                /* -- sets the number of hits -- */ 
     106                hits = toFilter.size(); 
     107 
     108                /* -- selects the interval of documents -- */ 
     109                long start = (searchType.getStart() > 0 && searchType.getStart() < toFilter.size()) ? searchType.getStart() : 0; 
     110 
     111                long howMany = searchType.getHowMany(); 
     112                if (howMany > 0) {                       
     113                        howMany = (toFilter.size() > howMany + start) ? howMany + start : toFilter.size() - start; 
     114                } else { 
     115                        howMany = toFilter.size(); 
     116                } 
     117 
     118                toFilter = toFilter.subList((int) start, (int) howMany); 
     119                res = retrieveDocuments(conn, toFilter); 
     120 
    107121                return res; 
    108122        } 
     
    117131         *             If a database access exception occurs 
    118132         */ 
    119         private Set<String> executeSearch(Connection conn, String sqlQuery) 
    120                         throws NdgSQLException { 
     133        private List<String> executeSearch(Connection conn, String sqlQuery) throws NdgSQLException { 
    121134                Statement stat = null; 
    122135                ResultSet rs = null; 
     
    127140                        closeStatement(stat, rs); 
    128141                        NdgMessage msg = new NdgMessage("sql.execution.error", 
    129                                         new Object[] { sqlQuery }); 
     142 
     143                        new Object[] { sqlQuery }); 
    130144                        throw new NdgSQLException(msg); 
    131145                } 
    132146 
    133                 Set<String> ret = new HashSet<String>(); 
     147                List<String> ret = new ArrayList<String>(); 
    134148                try { 
    135                         while (rs != null && !rs.isLast()) { 
     149                        while (rs != null && (rs.getRow() != 0) && !rs.isLast()) { 
    136150                                rs.next(); 
    137151                                ret.add(rs.getString(1)); 
    138152                        } 
    139153                } catch (SQLException e) { 
    140                         NdgMessage msg = new NdgMessage("sql.resultset.parsing.error", 
    141                                         new Object[] { sqlQuery }); 
     154                        NdgMessage msg = new NdgMessage("sql.resultset.parsing.error", new Object[] { sqlQuery }); 
    142155                        throw new NdgSQLException(msg); 
    143156                } finally { 
     
    156169         *             If a database access exception occurs 
    157170         */ 
    158         private Set<MEDINSearchResult> retrieveDocuments(Connection conn, 
    159                         Set<String> documentsId) throws NdgSQLException { 
     171        private List<OriginalDocument> retrieveDocuments(Connection conn, List<String> documentsId) throws NdgSQLException { 
     172                List<OriginalDocument> ret = new ArrayList<OriginalDocument>(); 
     173                if (documentsId == null || documentsId.size() == 0) 
     174                        return ret; 
    160175                Statement stat = null; 
    161176                ResultSet rs = null; 
     
    163178                NdgMessage msg = null; 
    164179                if (logger.isInfoEnabled()) { 
    165                         msg = new NdgMessage("sql.command", new Object[] { sqlQuery 
    166                                         .toString() }); 
     180                        msg = new NdgMessage("sql.command", new Object[] { sqlQuery.toString() }); 
    167181                        logger.info(getMsgFormatter().getFormattedText(msg)); 
    168182                } 
     
    172186                } catch (SQLException e) { 
    173187                        closeStatement(stat, rs); 
    174                         msg = new NdgMessage("sql.execution.error", 
    175                                         new Object[] { sqlQuery }); 
     188                        msg = new NdgMessage("sql.execution.error", new Object[] { sqlQuery }); 
    176189                        throw new NdgSQLException(msg); 
    177190                } 
    178191 
    179                 Set<MEDINSearchResult> ret = new HashSet<MEDINSearchResult>(); 
    180                 MEDINSearchResult item; 
     192                OriginalDocument item; 
    181193 
    182194                if (rs != null) { 
    183                         boolean doNext = false; 
    184195                        while (true) { 
    185196                                try { 
    186                                         if (!rs.next()) 
     197                                        if ((rs.getRow() == 0) || !rs.next()) 
    187198                                                break; 
    188199                                } catch (SQLException e) { 
     
    202213        } 
    203214 
    204         private String assembleRetrieve(Set<String> documentsId) { 
    205                  
    206                 DiscoveryDictionary.RecordDetailList type  
    207                         = Utilities.getRecordDetails(searchType.getRecordDetail()); 
     215        private String assembleRetrieve(List<String> documentsId) { 
     216 
     217                DiscoveryDictionary.RecordDetail type = DiscoveryDictionary.getRecordDetails(searchType.getRecordDetail()); 
    208218                StringBuffer sqlCmd = new StringBuffer("SELECT "); 
    209219 
    210220                /** all the IFs should be revisited */ 
    211                 if (type.equals(DiscoveryDictionary.RecordDetailList.DocumentId)) { 
     221                if (type.equals(DiscoveryDictionary.RecordDetail.DocumentId)) { 
    212222                        sqlCmd.append(" original_document_filename"); 
    213                 }                
    214                 if (type.equals(DiscoveryDictionary.RecordDetailList.DocumentBrief)) { 
     223                } 
     224                if (type.equals(DiscoveryDictionary.RecordDetail.DocumentBrief)) { 
    215225                        sqlCmd.append(" original_document_filename, dataset_name"); 
    216226                } 
    217                 if (type.equals(DiscoveryDictionary.RecordDetailList.DocumentSummary)) { 
    218                         sqlCmd 
    219                                         .append(" original_document_filename, dataset_name, dataset_abstract"); 
    220                 } 
    221                 if (type.equals(DiscoveryDictionary.RecordDetailList.DocumentFull)) { 
    222                         sqlCmd 
    223                                         .append(" original_document_filename, dataset_name, dataset_abstract, original_document"); 
     227                if (type.equals(DiscoveryDictionary.RecordDetail.DocumentSummary)) { 
     228                        sqlCmd.append(" original_document_filename, dataset_name, dataset_abstract"); 
     229                } 
     230                if (type.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) { 
     231                        sqlCmd.append(" original_document_filename, dataset_name, dataset_abstract, original_document"); 
    224232                } 
    225233 
    226234                /* -----WHERE----- */ 
    227235                StringBuffer whereSQL = new StringBuffer(); 
    228                 whereSQL 
    229                                 .append(" FROM original_document WHERE original_document_filename IN ("); 
     236                whereSQL.append(" FROM original_document WHERE original_document_filename IN ("); 
    230237 
    231238                Iterator<String> iter = documentsId.iterator(); 
     
    241248                /* -----ORDER BY----- */ 
    242249                StringBuffer orderSQL = getOrderBy(sqlCmd); 
    243                 /* -- Append the ORDER BY clause to the WHERE command -- */                      
     250                /* -- Append the ORDER BY clause to the WHERE command -- */ 
    244251                if (orderSQL.length() > 0) { 
    245252                        whereSQL.append(" ORDER BY "); 
    246253                        whereSQL.append(orderSQL); 
    247                 }        
     254                } 
    248255                /* -- Append the FROM-WHERE clause to the SELECT command -- */ 
    249256                sqlCmd.append(whereSQL); 
     
    251258        } 
    252259 
    253         private String assembleSearch(TermSearchType termType) { 
    254                 String term = termType.getTerm(); 
    255                 String[] termTarget = convertTermType(termType.getTermTargetArray()); 
    256  
    257                 if (termTarget == null || termTarget.length == 0) { 
    258                         termTarget = new String[] { DBProperties.DOCUMENT_TS_VECTOR }; 
    259                 } 
    260  
    261                 if (logger.isDebugEnabled()) { 
    262                         logger.debug("Search term: " + term); 
    263                         logger.debug("Searct termTarget: " + termTarget.toString()); 
    264                 } 
     260        private String assembleSearch(SearchCriteria criteria) { 
    265261 
    266262                // NB, we use the postgres text search function to do term searches 
    267263                StringBuffer sqlCmd = new StringBuffer("SELECT original_document_filename "); 
    268                  
     264 
    269265                StringBuffer fromSQL = new StringBuffer(); 
     266                StringBuffer whereSQL = new StringBuffer(); 
     267 
    270268                fromSQL.append(" FROM original_document "); 
    271                                  
     269 
    272270                // NB, historically, limited wildcard searches were possible with 
    273271                // eXist 
     
    284282                 * "strip(" + termColumn + ")::text ~ '" + term + "'"); } } else { 
    285283                 */ 
    286                 // if spaces are specified, these need to be turned into '&' 
    287                 // joins 
    288                 //term = term.replaceAll("([\\w\\(\\)])(\\s+)([!\\w\\(\\)])", "$1 & $3"); 
    289                 term = term.replaceAll("(\\bAND\\b)|(\\band\\b)|\\+", "&"); 
    290                 term = term.replaceAll("(\\bOR\\b)|(\\bor\\b)|\\|", "|"); 
    291                 term = term.replaceAll("(\\bNOT\\b)|(\\bnot\\b)\\-", "!"); 
    292                 fromSQL.append(", to_tsquery('" + term + "') AS query "); 
     284 
     285                /* -- is a SpatialSearch? -- */ 
     286                preapareSpatialSearch(fromSQL, whereSQL, criteria.getTermSearchArray()); 
     287 
     288                /* -- is a TemporalSearch? -- */ 
     289                preapareTemporalSearch(fromSQL, whereSQL, criteria.getTemporalSearch()); 
    293290                 
    294                 StringBuffer tsVector = new StringBuffer(); 
    295                 for (String column : termTarget) { 
    296                         if (tsVector.length() > 0) { 
    297                                 tsVector.append(" || "); 
    298                         } else { 
    299                                 tsVector.append("("); 
    300                         } 
    301                         tsVector.append(column); 
    302                 } 
    303                 tsVector.append(")"); 
    304                  
    305                 StringBuffer whereSQL = new StringBuffer(); 
    306                 if (tsVector.length() > 0) { 
    307                         whereSQL.append(" WHERE "); 
    308                         appendWhereClause(whereSQL, " query @@ " + tsVector.toString()); 
    309                 } 
    310                  
     291                /* -- has Scope request? -- */ 
     292                preapareScopeSearch(fromSQL, whereSQL, searchType.getScopeArray());              
     293 
    311294                /* -----ORDER BY----- */ 
    312295                StringBuffer orderSQL = getOrderBy(sqlCmd); 
    313                  
    314                 /* -- Append the ORDER BY clause to the WHERE command -- */                      
     296 
     297                /* -- Append the ORDER BY clause to the WHERE command -- */ 
    315298                if (orderSQL.length() > 0) { 
    316299                        whereSQL.append(" ORDER BY "); 
    317300                        whereSQL.append(orderSQL); 
    318                 }                
    319                  
    320                 /* -- Append the FROM clause to the SELECT command -- */         
     301                } 
     302 
     303                /* -- Append the FROM clause to the SELECT command -- */ 
    321304                sqlCmd.append(fromSQL); 
    322                                  
    323                 /* -- Append the WHERE clause to the FROM command -- */                  
     305 
     306                /* -- Append the WHERE clause to the FROM command -- */ 
     307                if (whereSQL.length() > 0) 
     308                        sqlCmd.append(" WHERE "); 
    324309                sqlCmd.append(whereSQL); 
    325                  
     310 
    326311                if (logger.isInfoEnabled()) 
    327312                        logger.info("SQL query generated: " + sqlCmd); 
     
    434419         */ 
    435420        private void appendWhereClause(StringBuffer whereSqlCmd, String clause) { 
    436                 if (!whereSqlCmd.toString().trim().equals("WHERE")) 
     421                if (!(whereSqlCmd.toString().trim().length() == 0)) 
    437422                        whereSqlCmd.append(" AND "); 
    438423                whereSqlCmd.append(clause); 
    439         } 
    440  
    441         private void isValidTermType(String termType) throws DiscoveryWSException { 
    442                 if (termType.equals(FULL_TEXT_TERM_TYPE) 
    443                                 || termType.equals(AUTHOR_TERM_TYPE) 
    444                                 || termType.equals(PARAMETER_TERM_TYPE)) { 
    445                         return; 
    446                 } 
    447                 String errorMessage = "Invalid termType, " 
    448                                 + termType 
    449                                 + " - please use getListNames to get the valid list of term types"; 
    450                 logger.warn(errorMessage); 
    451                 throw new DiscoveryWSException(errorMessage); 
    452424        } 
    453425 
     
    470442         * @return String : sql insert statement 
    471443         */ 
    472         private static String updateResultSetQueryString( 
    473                         String originalDocumentFilename, Integer updatedCountVal) { 
     444        private static String updateResultSetQueryString(String originalDocumentFilename, Integer updatedCountVal) { 
    474445 
    475446                // UPDATE original_document SET resultset_count = '1' WHERE 
    476447                // original_document_filename='badc.nerc.ac.uk__DIF__badc.nerc.ac.uk-DIF-dataent_11642968801511608.xml'; 
    477                 String statementStringBuild = "UPDATE original_document SET resultset_count = '" 
    478                                 + updatedCountVal.toString() 
    479                                 + "' WHERE original_document_filename = '" 
    480                                 + originalDocumentFilename + "';"; 
     448                String statementStringBuild = "UPDATE original_document SET resultset_count = '" + updatedCountVal.toString() 
     449                                + "' WHERE original_document_filename = '" + originalDocumentFilename + "';"; 
    481450 
    482451                return statementStringBuild; 
    483         } 
    484  
    485         private String getDocument(String termTarget, String decodedTerm) { 
    486                 return ""; 
    487         } 
    488  
    489         /** 
    490          * Converts the human-readable termType array coming from the 
    491          * WebServiceRequest, to a db-readable termType array. 
    492          *  
    493          * @param termType 
    494          *            the webService's termType request 
    495          * @return the db equivalent termType. If the argument is <code>null</code> 
    496          *         returns <code>null</code>, an empty <code>String[]</code> if the 
    497          *         the argument is empty 
    498          **/ 
    499         private String[] convertTermType(String[] termType) { 
    500                 if (termType == null) 
    501                         return null; 
    502  
    503                 List<String> ret = new ArrayList<String>(); 
    504                 for (String type : termType) { 
    505                         for (DiscoveryDictionary.TermTarget item : DiscoveryDictionary.TermTarget 
    506                                         .values()) { 
    507                                 if (type.equals(item.fieldLabel())) { 
    508                                         ret.add(item.fieldName()); 
    509                                         break; 
    510                                 } 
    511                         } 
    512                 } 
    513                 if (ret.isEmpty()) 
    514                         ret.add(DiscoveryDictionary.TermTarget.FullText.fieldName()); 
    515                 return ret.toArray(new String[] {}); 
    516452        } 
    517453 
     
    522458         *             reading its value 
    523459         **/ 
    524         private MEDINSearchResult fillMEDINSearchResult(ResultSet rs) 
    525                         throws SQLException { 
    526                 String origDocFileName = ""; 
     460        private OriginalDocument fillMEDINSearchResult(ResultSet rs) throws SQLException { 
     461                OriginalDocument od = new OriginalDocument(); 
     462 
    527463                if (columnExist(rs, "original_document_filename")) 
    528                         origDocFileName = rs.getString("original_document_filename"); 
    529  
    530                 String datasetName = ""; 
     464                        od.setOriginalDocumentFilename(rs.getString("original_document_filename")); 
     465 
    531466                if (columnExist(rs, "dataset_name")) 
    532                         datasetName = rs.getString("dataset_name"); 
    533  
    534                 String document = null; 
     467                        od.setDatasetName(rs.getString("dataset_name")); 
     468 
    535469                if (columnExist(rs, "original_document")) 
    536                         document = rs.getString("original_document"); 
    537  
    538                 String documentAbstract = null; 
     470                        od.setOriginalDocument(rs.getString("original_document")); 
     471 
    539472                if (columnExist(rs, "dataset_abstract")) 
    540                         documentAbstract = rs.getString("dataset_abstract"); 
    541  
    542                 return new MEDINSearchResult(origDocFileName, datasetName, document, 
    543                                 documentAbstract); 
     473                        od.setDatasetAbstract(rs.getString("dataset_abstract")); 
     474 
     475                NdgMessage msg = new NdgMessage("invocation.error", new Object[] { "Field.get(result)" });                       
     476                for (OrderByField order : DiscoveryDictionary.OrderByField.values()) { 
     477                        if (columnExist(rs, order.fieldName())) 
     478                                try { 
     479                                        PropertyDescriptor field = DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()); 
     480                                        Class<?> type = field.getPropertyType(); 
     481                                        if (String.class.isAssignableFrom(type)) { 
     482                                                DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()).getWriteMethod().invoke(od, rs.getString(order.fieldName())); 
     483                                        } else if (java.sql.Timestamp.class.isAssignableFrom(type)) { 
     484                                                DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()).getWriteMethod().invoke(od, rs.getTimestamp((order.fieldName())));                                   
     485                                        } else if (Integer.class.isAssignableFrom(type)) {               
     486                                                field.getWriteMethod().invoke(od, rs.getString(rs.getInt((order.fieldName()))));                                                                                         
     487                                        } 
     488                                } catch (IllegalArgumentException e) { 
     489                                        logger.error(msg, e); 
     490                                } catch (IllegalAccessException e) { 
     491                                        logger.error(msg, e); 
     492                                } catch (InvocationTargetException e) { 
     493                                        logger.error(msg, e); 
     494                                } 
     495                }                
     496                return od; 
    544497        } 
    545498 
     
    571524        } 
    572525 
    573         private void closeConnection(Connection conn) { 
    574                 try { 
    575                         if (conn != null) { 
    576                                 conn.close(); 
    577                         } 
    578                 } catch (Exception e) { 
    579                 } 
    580         } 
    581  
    582526        private void closeStatement(Statement stat, ResultSet rs) { 
    583527                try { 
     
    592536                } 
    593537        } 
    594          
    595         /** 
    596          * Return a properly build ORDER BY clause. The parameter sqlCmd represents the SELECT clause 
    597          * where the fields used by the ORDER BY clause have to be added. 
     538 
     539        /** 
     540         * Return a properly build ORDER BY clause. The parameter sqlCmd represents 
     541         * the SELECT clause where the fields used by the ORDER BY clause have to be 
     542         * added. 
    598543         * */ 
    599544        private StringBuffer getOrderBy(StringBuffer sqlCmd) { 
    600                 StringBuffer orderSQL = new StringBuffer();              
    601                 if (searchType.getOrderByArray() != null && searchType.getOrderByArray().length > 0) {                   
     545                StringBuffer orderSQL = new StringBuffer(); 
     546                if (searchType.getOrderByArray() != null && searchType.getOrderByArray().length > 0) { 
    602547                        // orderSQL.append(" ORDER BY "); 
    603548                        for (OrderByType order : searchType.getOrderByArray()) { 
    604                                 for (DiscoveryDictionary.OrderByField orderField : DiscoveryDictionary.OrderByField 
    605                                                 .values()) { 
    606                                         if (orderField.fieldLabel().equals(order.getOrderByField())) { 
    607                                                 /* -- Append the field to the ORDER BY command -- */ 
    608                                                 if (orderSQL.length() > 0) { 
    609                                                         orderSQL.append(" ,"); 
    610                                                 } 
    611                                                 orderSQL.append(orderField.fieldName()); 
    612                                                 /* -- Append the field to the SELECT command -- */                                               
    613                                                 if (sqlCmd.length() > 0) { 
    614                                                         sqlCmd.append(" ,"); 
    615                                                 } 
    616                                                 sqlCmd.append(orderField.fieldName()); 
    617                                                 DiscoveryDictionary.OrderDirection direction = DiscoveryDictionary.OrderDirection.DESC; 
    618                                                 for (DiscoveryDictionary.OrderDirection item : DiscoveryDictionary.OrderDirection 
    619                                                                 .values()) { 
    620                                                         if (order.getOrderByDirection().toString().equals( 
    621                                                                         item.fieldLabel())) { 
    622                                                                 direction = item; 
    623                                                                 break; 
    624                                                         } 
    625                                                 } 
    626                                                 /* -- Append direction for the ORDER BY specific field -- */ 
    627                                                 orderSQL.append(" "); 
    628                                                 orderSQL.append(direction.fieldName()); 
    629                                         } 
     549 
     550                                DiscoveryDictionary.OrderByField orderField = DiscoveryDictionary.getOrderByField(order 
     551                                                .getOrderByField()); 
     552                                if (orderField == null) 
     553                                        continue; 
     554 
     555                                /* -- Append the field to the ORDER BY command -- */ 
     556                                if (orderSQL.length() > 0) { 
     557                                        orderSQL.append(" ,"); 
    630558                                } 
    631                         }                
    632                 } 
     559                                orderSQL.append(orderField.fieldName()); 
     560                                /* -- Append the field to the SELECT command -- */ 
     561                                if (sqlCmd.length() > 0) { 
     562                                        sqlCmd.append(" ,"); 
     563                                } 
     564                                sqlCmd.append(orderField.fieldName()); //may be check the field name? 
     565                                if (order.getOrderByDirection() != null) { 
     566                                        DiscoveryDictionary.OrderDirection direction = DiscoveryDictionary.getOrderDirection(order 
     567                                                        .getOrderByDirection().toString()); 
     568                                        /* 
     569                                         * -- Append direction for the ORDER BY specific field -- 
     570                                         */ 
     571                                        orderSQL.append(" "); 
     572                                        orderSQL.append(direction.fieldName()); 
     573                                } 
     574 
     575                        } 
     576                } 
     577 
    633578                return orderSQL; 
    634579        } 
     580 
     581        private void preapareSpatialSearch(StringBuffer fromSQL, StringBuffer whereSQL, TermSearchType[] termsType) { 
     582                if (termsType == null || termsType.length == 0) 
     583                        return; 
     584 
     585                boolean secondPass = false; 
     586                int queryIndex = 0; 
     587                for (TermSearchType termType : termsType) { 
     588                        checkWHERE_AND(whereSQL, secondPass); 
     589                        String term = termType.getTerm(); 
     590                        DiscoveryDictionary.TermTarget termTarget = DiscoveryDictionary.getTermType(termType.getTermTarget()); 
     591 
     592                        /* 
     593                         * -- if some termType is incomplete returns what ready up to this 
     594                         * moment -- 
     595                         */ 
     596                        if (term == null || term.length() == 0) 
     597                                break; 
     598 
     599                        if (logger.isDebugEnabled()) { 
     600                                logger.debug("Search term: " + term); 
     601                                logger.debug("Searct termTarget: " + termTarget.toString()); 
     602                        } 
     603 
     604                        /* -- Converts the query string in a postgresql proper format -- */ 
     605                        term = term.replaceAll("(\\bAND\\b)|(\\band\\b)|\\+", "&"); 
     606                        term = term.replaceAll("(\\bOR\\b)|(\\bor\\b)|\\|", "|"); 
     607                        term = term.replaceAll("(\\bNOT\\b)|(\\bnot\\b)\\-", "!"); 
     608 
     609                        /* -- appends the terms (FROM part) -- */ 
     610                        checkFROMComma(fromSQL, false); 
     611 
     612                        fromSQL.append(" to_tsquery('"); 
     613                        fromSQL.append(term); 
     614                        fromSQL.append("') AS query" + Integer.toString(queryIndex)); 
     615 
     616                        whereSQL.append(" query" + Integer.toString(queryIndex) + " @@ ("); 
     617                        whereSQL.append(termTarget.fieldName()); 
     618                        whereSQL.append(") "); 
     619                        secondPass = true; 
     620                        queryIndex++; 
     621                } 
     622        } 
     623 
     624        private void preapareTemporalSearch(StringBuffer fromSQL, StringBuffer whereSQL, TemporalType temporalType) { 
     625                if (temporalType == null || temporalType.getDateRange() == null 
     626                                || temporalType.getDateRange().getDateArray().length == 0) 
     627                        return; 
     628 
     629                DateRangeType dataRangeType = temporalType.getDateRange(); 
     630                DiscoveryDictionary.DateRangeTarget rangeTarget = DiscoveryDictionary.getDateRangeTarget(dataRangeType 
     631                                .getDateRangeTarget()); 
     632                DateValueType[] dateValues = dataRangeType.getDateArray(); 
     633                boolean secondPass = false; 
     634 
     635                if (!rangeTarget.equals(DiscoveryDictionary.DateRangeTarget.TemporalCoverage)) { 
     636                        for (DateValueType dataValue : dateValues) { 
     637                                checkWHERE_AND(whereSQL, secondPass); 
     638                                TemporalOperator operator = DiscoveryDictionary.getTemporalOperator(dataValue.getTemporalOperator()); 
     639                                whereSQL.append(" " + rangeTarget.fieldName()); 
     640                                whereSQL.append(" " + operator.fieldName()); 
     641                                whereSQL.append(" " + dataValue.getDateValue1()); 
     642                                secondPass = true; 
     643                        } 
     644                } else { 
     645                        checkFROMComma(fromSQL, false); 
     646                        fromSQL.append(" temporal_data"); 
     647                         
     648                        checkWHERE_AND(fromSQL, false); 
     649                        whereSQL.append(" original_document.id == temporal_data.original_document_id "); 
     650                        whereSQL.append(" AND "); 
     651                         
     652                        secondPass = false; 
     653                        for (DateValueType dataValue : dateValues) { 
     654                                checkWHERE_AND(whereSQL, secondPass); 
     655                                TemporalOperator operator = DiscoveryDictionary.getTemporalOperator(dataValue.getTemporalOperator()); 
     656                                whereSQL.append(" temporal_data.start_time "); 
     657                                whereSQL.append(" " + operator.fieldName()); 
     658                                whereSQL.append(dataValue.getDateValue1()); 
     659                                whereSQL.append(" AND "); 
     660                                whereSQL.append(" temporal_data.end_time "); 
     661                                whereSQL.append(" " + operator.fieldName()); 
     662                                whereSQL.append(dataValue.getDateValue1() + " "); 
     663                                secondPass = true; 
     664                        } 
     665                } 
     666 
     667        } 
     668         
     669        private void preapareScopeSearch(StringBuffer fromSQL, StringBuffer whereSQL, String[] scopes) { 
     670                if (scopes == null || scopes.length == 0) 
     671                        return; 
     672 
     673                        /* -- appends the terms (FROM part) -- */ 
     674                        checkFROMComma(fromSQL, false); 
     675                        fromSQL.append(" to_tsquery("); 
     676                        boolean secondPass = false; 
     677                        for (String scopeLabel : scopes) { 
     678                                DiscoveryDictionary.Scope scope = DiscoveryDictionary.getScope(scopeLabel); 
     679                                if (logger.isDebugEnabled()) { 
     680                                        logger.debug("Scope: " + scope); 
     681                                } 
     682                                if (secondPass)  
     683                                        whereSQL.append(" & "); 
     684                                fromSQL.append(" '" + scope.fieldName() + "' "); 
     685                        } 
     686                        fromSQL.append(") AS scopeQuery "); 
     687                         
     688                        checkWHERE_AND(whereSQL, false); 
     689                        whereSQL.append(" scopeQuery @@ (scope_ts_vector) "); 
     690 
     691 
     692                         
     693        }        
     694         
     695        /** 
     696         * Appends a comma to the given <code>StringBuffer</code> if 
     697         * <ul> 
     698         * <li> secondPass is <code>true</code></li> 
     699         * <li> secondPass is <code>false</code> AND <code>sb</code>'s length &gt 0 </li>  
     700         * </ul> 
     701         **/ 
     702        private void checkFROMComma(StringBuffer sb, boolean secondPass) { 
     703                if (secondPass) { 
     704                        sb.append(", "); 
     705                } else { 
     706                        if (sb.length() > 0) 
     707                                sb.append(", "); 
     708                } 
     709        } 
     710         
     711        /** 
     712         * Appends an "AND" to the given <code>StringBuffer</code> if 
     713         * <ul> 
     714         * <li> secondPass is <code>true</code></li> 
     715         * or 
     716         * <li> secondPass is <code>false</code> AND <code>sb</code>'s length &gt 0 </li>  
     717         * </ul> 
     718         **/     
     719        private void checkWHERE_AND(StringBuffer sb, boolean secondPass) { 
     720                if (secondPass) { 
     721                        sb.append(" AND "); 
     722                } else { 
     723                        if (sb.length() > 0) 
     724                                sb.append(" AND "); 
     725                } 
     726        } 
    635727} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/resources/META-INF/Discovery.wsdl

    r6456 r6504  
    6767                                </xs:complexType> 
    6868                        </xs:element> 
    69                         <xs:element name="Start" type="xs:positiveInteger" minOccurs="0"> 
     69                        <xs:element name="Start" type="xs:unsignedInt" minOccurs="0"> 
    7070                                <xs:annotation> 
    7171                                        <xs:documentation>Sequential record number within result set used as first record within returned search response. Useful for pagination.</xs:documentation> 
    7272                                </xs:annotation> 
    7373                        </xs:element> 
    74                         <xs:element name="HowMany" type="xs:positiveInteger" minOccurs="0"> 
     74                        <xs:element name="HowMany" type="xs:unsignedInt" minOccurs="0"> 
    7575                                <xs:annotation> 
    7676                                        <xs:documentation>How many records from result set to include in search response.</xs:documentation> 
     
    178178        <xs:complexType name="BoundingBoxType"> 
    179179                <xs:all> 
    180                         <xs:element name="LimitNorth" type="xs:decimal"/> 
    181                         <xs:element name="LimitSouth" type="xs:decimal"/> 
    182                         <xs:element name="LimitWest" type="xs:decimal"/> 
    183                         <xs:element name="LimitEast" type="xs:decimal"/> 
     180                        <xs:element name="LimitNorth" type="xs:float"/> 
     181                        <xs:element name="LimitSouth" type="xs:float"/> 
     182                        <xs:element name="LimitWest" type="xs:float"/> 
     183                        <xs:element name="LimitEast" type="xs:float"/> 
    184184                </xs:all> 
    185185        </xs:complexType> 
     
    231231                                </xs:annotation> 
    232232                        </xs:element> 
    233                         <xs:element name="TermTarget" type="xs:string" minOccurs="0" maxOccurs="unbounded"> 
     233                        <xs:element name="TermTarget" type="xs:string" minOccurs="0" maxOccurs="1"> 
    234234                                <xs:annotation> 
    235235                                        <xs:documentation>Metadata field used as target for search. From list termTargetList</xs:documentation> 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/resources/META-INF/DiscoverySchema.xsd

    r6456 r6504  
    6565                                </xs:complexType> 
    6666                        </xs:element> 
    67                         <xs:element name="Start" type="xs:positiveInteger" minOccurs="0"> 
     67                        <xs:element name="Start" type="xs:unsignedInt" minOccurs="0"> 
    6868                                <xs:annotation> 
    6969                                        <xs:documentation>Sequential record number within result set used as first record within returned search response. Useful for pagination.</xs:documentation> 
    7070                                </xs:annotation> 
    7171                        </xs:element> 
    72                         <xs:element name="HowMany" type="xs:positiveInteger" minOccurs="0"> 
     72                        <xs:element name="HowMany" type="xs:unsignedInt" minOccurs="0"> 
    7373                                <xs:annotation> 
    7474                                        <xs:documentation>How many records from result set to include in search response.</xs:documentation> 
     
    176176        <xs:complexType name="BoundingBoxType"> 
    177177                <xs:all> 
    178                         <xs:element name="LimitNorth" type="xs:decimal"/> 
    179                         <xs:element name="LimitSouth" type="xs:decimal"/> 
    180                         <xs:element name="LimitWest" type="xs:decimal"/> 
    181                         <xs:element name="LimitEast" type="xs:decimal"/> 
     178                        <xs:element name="LimitNorth" type="xs:float"/> 
     179                        <xs:element name="LimitSouth" type="xs:float"/> 
     180                        <xs:element name="LimitWest" type="xs:float"/> 
     181                        <xs:element name="LimitEast" type="xs:float"/> 
    182182                </xs:all> 
    183183        </xs:complexType> 
     
    229229                                </xs:annotation> 
    230230                        </xs:element> 
    231                         <xs:element name="TermTarget" type="xs:string" minOccurs="0" maxOccurs="unbounded"> 
     231                        <xs:element name="TermTarget" type="xs:string" minOccurs="0" maxOccurs="1"> 
    232232                                <xs:annotation> 
    233233                                        <xs:documentation>Metadata field used as target for search. From list termTargetList</xs:documentation> 
Note: See TracChangeset for help on using the changeset viewer.