Changeset 6659 for TI01-discovery-API


Ignore:
Timestamp:
02/03/10 10:29:01 (9 years ago)
Author:
mnagni
Message:

Implemented the OriginalFormat? (SearchType?) and the MetadataFormat? (RetrieveType?)
Updated the OriginalDocument? class

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

Legend:

Unmodified
Added
Removed
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/DiscoveryServiceMEDINSkeleton.java

    r6632 r6659  
    1212import ndg.services.discovery.exception.DiscoveryWSException; 
    1313import ndg.services.discovery.medin.DiscoveryDictionary; 
    14 import ndg.services.discovery.medin.DoPresentDocument; 
    15 import ndg.services.discovery.medin.DoPresentReturnDocument; 
    16 import ndg.services.discovery.medin.DoSearchDocument; 
    17 import ndg.services.discovery.medin.DoSearchReturnDocument; 
    18 import ndg.services.discovery.medin.Documents; 
    19 import ndg.services.discovery.medin.GetListDocument; 
    20 import ndg.services.discovery.medin.GetListNamesDocument; 
    21 import ndg.services.discovery.medin.GetListNamesReturnDocument; 
    22 import ndg.services.discovery.medin.GetListNamesReturnType; 
    23 import ndg.services.discovery.medin.GetListReturnDocument; 
    24 import ndg.services.discovery.medin.GetListReturnType; 
    25 import ndg.services.discovery.medin.GetListType; 
    26 import ndg.services.discovery.medin.OrderByType; 
    27 import ndg.services.discovery.medin.OrderingMetricType; 
    28 import ndg.services.discovery.medin.PresentReturnType; 
    29 import ndg.services.discovery.medin.RetrieveCriteriaType; 
    30 import ndg.services.discovery.medin.ReturnBriefType; 
    31 import ndg.services.discovery.medin.ReturnFullType; 
    32 import ndg.services.discovery.medin.ReturnSimpleType; 
    33 import ndg.services.discovery.medin.ReturnSummaryType; 
    34 import ndg.services.discovery.medin.SearchReturnType; 
    35 import ndg.services.discovery.medin.SearchType; 
    36 import ndg.services.discovery.medin.SimpleDocument1; 
    3714import ndg.services.discovery.medin.DiscoveryDictionary.OrderByField; 
    3815import ndg.services.discovery.medin.DiscoveryDictionary.RecordDetail; 
     16import ndg.services.discovery.medin.schema.CustomInfo; 
     17import ndg.services.discovery.medin.schema.DoPresentDocument; 
     18import ndg.services.discovery.medin.schema.DoPresentReturnDocument; 
     19import ndg.services.discovery.medin.schema.DoSearchDocument; 
     20import ndg.services.discovery.medin.schema.DoSearchReturnDocument; 
     21import ndg.services.discovery.medin.schema.Documents; 
     22import ndg.services.discovery.medin.schema.GetListDocument; 
     23import ndg.services.discovery.medin.schema.GetListNamesDocument; 
     24import ndg.services.discovery.medin.schema.GetListNamesReturnDocument; 
     25import ndg.services.discovery.medin.schema.GetListNamesReturnType; 
     26import ndg.services.discovery.medin.schema.GetListReturnDocument; 
     27import ndg.services.discovery.medin.schema.GetListReturnType; 
     28import ndg.services.discovery.medin.schema.GetListType; 
     29import ndg.services.discovery.medin.schema.OrderByType; 
     30import ndg.services.discovery.medin.schema.OrderingMetricType; 
     31import ndg.services.discovery.medin.schema.PresentReturnType; 
     32import ndg.services.discovery.medin.schema.RetrieveCriteriaType; 
     33import ndg.services.discovery.medin.schema.ReturnBriefType; 
     34import ndg.services.discovery.medin.schema.ReturnFullType; 
     35import ndg.services.discovery.medin.schema.ReturnSimpleType; 
     36import ndg.services.discovery.medin.schema.ReturnSummaryType; 
     37import ndg.services.discovery.medin.schema.SearchReturnType; 
     38import ndg.services.discovery.medin.schema.SearchType; 
     39import ndg.services.discovery.medin.schema.SimpleDocument1; 
    3940import ndg.services.discovery.model.PresentAgent; 
    4041import ndg.services.discovery.model.SearchAgent; 
     
    4243 
    4344import org.apache.log4j.Logger; 
     45 
    4446 
    4547 
     
    5355 
    5456        private static Logger logger = Logger.getLogger(DiscoveryDBException.class.getName()); 
    55  
    56         // Constants representing the possible, valid values for the various input 
    57         // list types 
    58  
    59         // Terms for : TermTargetList 
    60  
    61         // public static final String FULLTEXT_TERMTARGET = "FullText"; 
    62         // public static final String AUTHOR_TERMTARGET = "Author"; 
    63         // public static final String PARAMETER_TERMTARGET = "Parameter"; 
    64         // public static final String MEDIN_TERM_TARGET_TERMTARGET = 
    65         // "MEDINTermTarget.1"; 
    66  
    67         // Terms for : PresentFormatList 
    68  
    69         public static final String DC_PRESENTFORMAT = "DC"; 
    70         public static final String DIF_v9_4_PRESENTFORMAT = "DIF_v9.4"; 
    71         public static final String MEDIN_v2_3_1_PRESENTFORMAT = "MEDIN_v2.3.1"; 
    72         public static final String ISO19115_PRESENTFORMAT = "ISO19115"; 
    73  
    74         // Terms for : OrderByFieldList 
    7557 
    7658        // NOTE - when specifying text relevance ranking further parsing is required 
     
    8971        public static final String MEDINTERMTARGET1_ORDERBYFIELD = "MEDINTermTarget.1"; 
    9072 
    91         // Terms for : ScopeList 
    92  
    93         public static final String MEDIN_SCOPE = "MEDIN"; 
    94         public static final String NERC_DDC_SCOPE = "NERC_DDC"; 
    95         public static final String NERC_SCOPE = "NERC"; 
    96         public static final String DPPP_SCOPE = "DPPP"; 
    97  
    98         // Terms for : SpatialOperatorList 
    99  
    100         public static final String OVERLAPS_SPATIALOPERATOR = "Overlaps"; 
    101         public static final String DOESNOTOVERLAP_SPATIALOPERATOR = "DoesNotOverlap"; 
    102         public static final String WITHIN_SPATIALOPERATOR = "Within"; 
    103  
    104         // Terms for : SpatialReferenceSystemList 
    105         public static final String EPSG4326_SPATIALREFERENCESYSTEM = "EPSG:4326"; 
    106  
    107         // Terms for : MetadataFormatList 
    108  
    109         public static final String DC_METADATAFORMAT = "DC"; 
    110         public static final String DIF_v9_4_METADATAFORMAT = "DIF_v9.4"; 
    111         public static final String MEDIN_V2_3_1_METADATAFORMAT = "MEDIN_v2.3.1"; 
    112         public static final String ISO19115_METADATAFORMAT = "ISO19115"; 
    113  
    114         // Terms for : RecordDetailList 
    115  
    116         // public static final String ID_RECORDDETAIL = "Id"; 
    117         // public static final String BRIEF_RECORDDETAIL = "Brief"; 
    118         // public static final String SUMMARY_RECORDDETAIL = "Summary"; 
    119  
    12073        // Other constants 
    12174 
     
    13992        public GetListNamesReturnDocument getListNames( 
    14093                        GetListNamesDocument getListNames) { 
    141                 // TODO : fill this with the necessary business logic 
    142                 // throw new java.lang.UnsupportedOperationException("Please implement " 
    143                 // + this.getClass().getName() + "#getListNames"); 
    144  
    14594                /*--- Generated by WSDL2Code, DO NOT TOUCH ---*/ 
    14695                GetListNamesReturnDocument response = GetListNamesReturnDocument.Factory 
     
    194143                        status = (result != null && result.size() > 0 ? true : false); 
    195144                } catch (NdgSQLException e) { 
     145                        if (logger.isErrorEnabled()) 
     146                                logger.error(e.getMessage()); 
    196147                        statusMessage = e.getMessage(); 
    197148                } catch (ResourceNotAvailable e) { 
     149                        if (logger.isErrorEnabled()) 
     150                                logger.error(e.getMessage()); 
    198151                        statusMessage = e.getMessage(); 
    199152                } finally { 
     
    224177                                documentsId.add(doc.getDocumentId()); 
    225178                        } 
    226                         RecordDetail detail = RecordDetail.DocumentFull; 
    227                         List<OriginalDocument> result = agent.doPresent(null, documentsId, detail); 
     179                        RetrieveCriteriaType retrieveType = doPresent.getDoPresent().getRetrieveCriteria(); 
     180                        List<OriginalDocument> result = agent.doPresent(null, documentsId, retrieveType); 
     181                        String recDetail = retrieveType == null ? null : retrieveType.getRecordDetail(); 
     182                        DiscoveryDictionary.RecordDetail detail = DiscoveryDictionary.getRecordDetails(recDetail); 
    228183                        processResult(result, responseContent.addNewDocuments(), detail, null); 
    229184                        status = (result != null && result.size() >      0 ? true : false); 
     
    270225                                list.addListMember(item.fieldLabel()); 
    271226                        } 
    272                 } else if (listName.equals(DiscoveryDictionary.Names.PresentFormat)) { 
    273                         list.addListMember(DC_PRESENTFORMAT); 
    274                         list.addListMember(DIF_v9_4_PRESENTFORMAT); 
    275                         list.addListMember(MEDIN_v2_3_1_PRESENTFORMAT); 
    276                         list.addListMember(ISO19115_PRESENTFORMAT); 
    277227                } else if (listName.equals(DiscoveryDictionary.Names.OrderByField)) { 
    278228                        for (DiscoveryDictionary.OrderByField item : DiscoveryDictionary.OrderByField.values()) { 
    279229                                list.addListMember(item.fieldLabel()); 
    280230                        } 
    281                         /* 
    282                          * list.addListMember(TEXTRELEVANCE_ORDERBYFIELD); 
    283                          * list.addListMember(DATASETORDER_ORDERBYFIELD); 
    284                          * list.addListMember(DATASETSTARTDATE_ORDERBYFIELD); 
    285                          * list.addListMember(DATASETENDDATE_ORDERBYFIELD); 
    286                          * list.addListMember(DATACEENTRE_ORDERBYFIELD); 
    287                          * list.addListMember(DATASETRESULTSETPOPULARITY_ORDERBYFIELD); 
    288                          * list.addListMember(PROXIMITY_ORDERBYFIELD); 
    289                          * list.addListMember(PROXIMITYNEARMISS_ORDERBYFIELD); 
    290                          * list.addListMember(DATASETUPDATEORDER_ORDERBYFIELD); 
    291                          * list.addListMember(DATASETORDER_ORDERBYFIELD); 
    292                          * list.addListMember(DISCOVERYINGESTDATE_ORDERBYFIELD); 
    293                          * list.addListMember(MEDINTERMTARGET1_ORDERBYFIELD); 
    294                          */ 
    295231                } else if (listName.equals(DiscoveryDictionary.Names.Scope)) { 
    296                         list.addListMember(MEDIN_SCOPE); 
    297                         list.addListMember(NERC_DDC_SCOPE); 
    298                         list.addListMember(NERC_SCOPE); 
    299                         list.addListMember(DPPP_SCOPE); 
     232                        for (DiscoveryDictionary.Scope item : DiscoveryDictionary.Scope.values()) { 
     233                                list.addListMember(item.fieldLabel()); 
     234                        } 
    300235                } else if (listName.equals(DiscoveryDictionary.Names.SpatialOperator)) { 
    301                         list.addListMember(OVERLAPS_SPATIALOPERATOR); 
    302                         list.addListMember(DOESNOTOVERLAP_SPATIALOPERATOR); 
    303                         list.addListMember(WITHIN_SPATIALOPERATOR); 
     236                        for (DiscoveryDictionary.SpatialOperator item : DiscoveryDictionary.SpatialOperator.values()) { 
     237                                list.addListMember(item.fieldLabel()); 
     238                        } 
    304239                } else if (listName.equals(DiscoveryDictionary.Names.SpatialReferenceSystem)) { 
    305                         list.addListMember(EPSG4326_SPATIALREFERENCESYSTEM); 
     240                        for (DiscoveryDictionary.SpatialReferenceSystem item : DiscoveryDictionary.SpatialReferenceSystem.values()) { 
     241                                list.addListMember(item.fieldLabel()); 
     242                        } 
    306243                } else if (listName.equals(DiscoveryDictionary.Names.DateRangeTarget)) { 
    307244                        for (DiscoveryDictionary.DateRangeTarget item : DiscoveryDictionary.DateRangeTarget.values()) { 
     
    313250                        } 
    314251                } else if (listName.equals(DiscoveryDictionary.Names.MetadataFormat)) { 
    315                         list.addListMember(DC_METADATAFORMAT); 
    316                         list.addListMember(DIF_v9_4_METADATAFORMAT); 
    317                         list.addListMember(MEDIN_V2_3_1_METADATAFORMAT); 
    318                         list.addListMember(ISO19115_METADATAFORMAT); 
     252                        for (DiscoveryDictionary.MetadataFormat item : DiscoveryDictionary.MetadataFormat.values()) { 
     253                                list.addListMember(item.fieldLabel()); 
     254                        } 
    319255                } else if (listName.equals(DiscoveryDictionary.Names.RecordDetail)) { 
    320256                        for (DiscoveryDictionary.RecordDetail item : DiscoveryDictionary.RecordDetail.values()) { 
     
    404340                if (results != null && results.size() == 0) 
    405341                        return; 
     342                Object documentType = null; 
    406343                for (OriginalDocument result : results) { 
    407344                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentSimple)) { 
    408345                                ReturnSimpleType simpleType = documents.addNewDocumentSimple(); 
    409                                 simpleType.setDocumentId(result.getOriginalDocumentFilename()); 
     346                                fillDocument(simpleType, result); 
    410347                                continue; 
    411348                        } 
     
    413350                        /* -- Please note that the following IF do not own a continue  
    414351                         * statement in order to execute the final 'fillOrderedField' -- */ 
    415                         Object documentType = null; 
    416                         if (type.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) { 
    417                                 ReturnFullType fullType = documents.addNewDocumentFull();                                
    418                                 fullType.setDocumentId(result.getOriginalDocumentFilename()); 
    419                                 fullType.setTitle(result.getDatasetName()); 
    420                                 fullType.setDocument(result.getOriginalDocument()); 
    421                                 fullType.setAbstract(result.getDatasetAbstract()); 
    422                                 documentType = fullType;                                                         
     352                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) {                                
     353                                ReturnFullType fullType = documents.addNewDocumentFull();        
     354                                fillDocument(fullType, result); 
     355                                documentType = fullType; 
    423356                        } 
    424357                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentSummary)) { 
    425358                                ReturnSummaryType summaryType = documents.addNewDocumentSummary(); 
    426                                 summaryType.setDocumentId(result.getOriginalDocumentFilename()); 
    427                                 summaryType.setTitle(result.getDatasetName()); 
    428                                 summaryType.setAbstract(result.getDatasetAbstract()); 
    429                                 documentType = summaryType; 
     359                                fillDocument(summaryType, result); 
     360                                documentType = summaryType;                              
    430361                        } 
    431362                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentBrief)) { 
    432363                                ReturnBriefType briefType = documents.addNewDocumentBrief(); 
    433                                 briefType.setDocumentId(result.getOriginalDocumentFilename()); 
    434                                 briefType.setTitle(result.getDatasetName()); 
    435                                 documentType = briefType; 
     364                                fillDocument(briefType, result); 
     365                                documentType = briefType;                                
    436366                        } 
    437367                        if (orderBy != null)  
     
    439369                } 
    440370        } 
     371         
     372         
    441373         
    442374        /** 
     
    445377         * Obviously if the user request included the request to sort by some field.  
    446378         **/ 
    447         private void fillOrderedFieldArray(Object documentType, OrderByType[] orders, OriginalDocument result) { 
     379        private <T> void fillOrderedFieldArray(T documentType, OrderByType[] orders, OriginalDocument result) { 
    448380                for (OrderByType orderType : orders) { 
    449381                        OrderByField order = DiscoveryDictionary.getOrderByField(orderType.getOrderByField()); 
     
    451383                                continue; 
    452384                        OrderingMetricType newOMT = getNewOMT(documentType); 
     385                        if (newOMT == null) 
     386                                continue; 
    453387                        newOMT.setMetricName(order.fieldLabel()); 
    454388                        String value = "DataError"; 
     
    456390                        try { 
    457391                                PropertyDescriptor field = DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()); 
    458                                 value = field.getReadMethod().invoke(result, new Object[0]).toString(); 
     392                                Object objValue = field.getReadMethod().invoke(result, new Object[0]); 
     393                                value = (objValue != null ? objValue.toString() : ""); 
    459394                                newOMT.setMetricValue(value); 
    460395                        } catch (IllegalArgumentException e) { 
     
    468403        } 
    469404         
     405         
     406         
    470407        /** 
    471408         * Creates in the given <code>documentType</code>, and returns it,  
     
    474411        private OrderingMetricType getNewOMT(Object documentType){ 
    475412                OrderingMetricType ret = null; 
     413                if (ReturnSimpleType.class.isAssignableFrom(documentType.getClass())){ 
     414                        ret = null; 
     415                }                
    476416                if (ReturnFullType.class.isAssignableFrom(documentType.getClass())){ 
    477417                        ReturnFullType tmp = (ReturnFullType)documentType; 
     
    487427                } 
    488428                return ret; 
    489         }        
     429        } 
     430                 
     431        private void fillCustomInfo(CustomInfo info, OriginalDocument result) { 
     432                info.setAuthors(result.getAuthors() != null ? result.getAuthors() : ""); 
     433                info.setOriginalFormatName(result.getOriginalFormatName() != null ? result.getOriginalFormatName() : ""); 
     434                info.setDataOriginator(result.getDataOriginator() != null ? result.getDataOriginator() : ""); 
     435                info.setLineage(result.getLineage() != null ? result.getLineage() : ""); 
     436                info.setParameters(result.getParameters() != null ? result.getParameters() : ""); 
     437                info.setLimitationsPublicAccess(result.getLimitationsPublicAccess() != null ? result.getLimitationsPublicAccess() : ""); 
     438                info.setResourceType(result.getResourceType() != null ? result.getResourceType() : ""); 
     439                info.setTopicCategory(result.getTopicCategory() != null ? result.getTopicCategory() : ""); 
     440        } 
     441         
     442        private void fillDocument(ReturnFullType type, OriginalDocument result){                         
     443                type.setDocumentId(result.getOriginalDocumentFilename()); 
     444                type.setTitle(result.getDatasetName()); 
     445                type.setDocument(result.getOriginalDocument()); 
     446                type.setAbstract(result.getDatasetAbstract()); 
     447                CustomInfo info = type.addNewAdditionalInformation(); 
     448                fillCustomInfo(info, result); 
     449        } 
     450         
     451        private void fillDocument(ReturnSummaryType type, OriginalDocument result){                      
     452                type.setDocumentId(result.getOriginalDocumentFilename()); 
     453                type.setTitle(result.getDatasetName()); 
     454                type.setAbstract(result.getDatasetAbstract()); 
     455        } 
     456         
     457        private void fillDocument(ReturnBriefType type, OriginalDocument result){                        
     458                type.setDocumentId(result.getOriginalDocumentFilename()); 
     459                type.setTitle(result.getDatasetName()); 
     460                CustomInfo info = type.addNewAdditionalInformation(); 
     461                fillCustomInfo(info, result); 
     462        } 
     463         
     464        private void fillDocument(ReturnSimpleType type, OriginalDocument result){                       
     465                type.setDocumentId(result.getOriginalDocumentFilename()); 
     466        } 
    490467} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/medin/DiscoveryDictionary.java

    r6632 r6659  
    1515public final class DiscoveryDictionary { 
    1616 
     17        public final static String SPATIAL_DATA_TABLE  = "spatial_data"; 
     18        public final static String TEMPORAL_DATA_TABLE = "temporal_data"; 
     19        public final static String ORIGINAL_DOCUMENT_TABLE = "original_document"; 
     20        public final static String TRANSFORMED_DOCUMENT_TABLE = "transformed_document"; 
     21        public final static String FULL_DOCUMENT = "fullDocument"; 
     22         
    1723        public static enum Names { 
    18                 TermTarget("TermTarget", "Term Target"), 
    19                 PresentFormat("PresentFormat", "Present Format"), 
    20                 OrderByField("OrderByField", "Order By Field"), 
    21                 Scope("Scope", "Scope"), 
    22                 SpatialOperator("SpatialOperator", "Spatial Operator"), 
    23                 SpatialReferenceSystem("SpatialReferenceSystem", "Spatial Reference System"), 
    24                 DateRangeTarget("DateRangeTarget", "Date Range Target"), 
    25                 TemporalOperator("TemporalOperator", "Temporal Operator"), 
    26                 MetadataFormat("MetadataFormat", "Metadata Format"), 
    27                 RecordDetail("RecordDetail", "Record Detail"),;          
     24                TermTarget("TermTarget", "TermTargetList"), 
     25                OriginalFormat("OriginalFormat", "OriginalFormatList"), 
     26                OrderByField("OrderByField", "OrderByFieldList"), 
     27                Scope("Scope", "ScopeList"), 
     28                SpatialOperator("SpatialOperator", "SpatialOperatorList"), 
     29                SpatialReferenceSystem("SpatialReferenceSystem", "SpatialReferenceSystemList"), 
     30                DateRangeTarget("DateRangeTarget", "DateRangeTargetList"), 
     31                TemporalOperator("TemporalOperator", "TemporalOperatorList"), 
     32                MetadataFormat("MetadataFormat", "MetadataFormatList"), 
     33                RecordDetail("RecordDetail", "RecordDetailList"),;               
    2834                 
    2935                private final String fieldName; 
     
    4450                FullText("document_ts_vector", "FullText"), 
    4551                Author("authors_ts_vector", "Author"), 
    46                 MedinTermTarget("MEDINTermTarget.1", "MEDINTermTarget.1"), 
    47                 Parameter("", "Parameter");              
     52                Parameters("parameters_ts_vector", "Parameters"), 
     53                ResourceType("resource_type_ts_vector", "ResourceType"), 
     54                TopicCategory("topic_category_ts_vector", "TopicCategory"), 
     55                Lineage("lineage_ts_vector", "Lineage"), 
     56                PublicAccessLimits("limitations_public_access_ts_vector", "PublicAccessLimits"), 
     57                DataOriginator("data_originator_tsvector", "DataOriginator"), 
     58                DataFormat("original_format_name", "DataFormat");                
    4859                 
    4960                private final String fieldName; 
     
    6273         
    6374        public static enum OrderByField { 
    64                 DatasetStartDate("dataset_start_date_nom", "DatasetStartDate", "datasetStartDateNom"), 
    65                 DatasetEndDate("dataset_end_date_nom", "DatasetEndDate", "datasetEndDateNom"),   
    66                 DataCenter("datacentre_name", "DataCenter", "datacentreName"), 
    67                 DatasetUpdate("update_date", "DatasetUpdateOrder", "updateDate"), 
    68                 DiscoveryIngestDate("create_date", "DiscoveryIngestDate", "createDate"); 
     75                DatasetStartDate("original_document.dataset_start_date_nom", "DatasetStartDate", "datasetStartDateNom"), 
     76                DatasetEndDate("original_document.dataset_end_date_nom", "DatasetEndDate", "datasetEndDateNom"),         
     77                DataCenter("original_document.datacentre_name", "DataCenter", "datacentreName"), 
     78                DatasetUpdate("original_document.update_date", "DatasetUpdateOrder", "updateDate"), 
     79                DiscoveryIngestDate("original_document.create_date", "DiscoveryIngestDate", "createDate"); 
    6980                 
    7081                private final String fieldName; 
     
    8596                        return odField; 
    8697                }                
    87  
    8898        } 
    8999         
     
    127137         
    128138        public static enum DateRangeTarget { 
    129                 TemporalCoverage("TemporalCoverage", "Temporal Coverage"), 
    130                 LastRevisionDate("dataset_metadata_update_date", "Last Revision Date"), 
    131                 DiscoveryIngestDate("update_date", "Discovery Ingest Date");             
     139                TemporalCoverage("TemporalCoverage", "TemporalCoverage"), 
     140                LastRevisionDate("dataset_metadata_update_date", "LastRevisionDate"), 
     141                DiscoveryIngestDate("update_date", "DiscoveryIngestDate");               
    132142                 
    133143                private final String fieldName; 
     
    147157        public static enum TemporalOperator { 
    148158                Equals("=", "Equals"), 
    149                 DoesNotEqual("<>", "Does Not Equal"), 
    150                 OnOrBefore("<=", "On Or Before"), 
    151                 OnOrAfter(">=", "On Or After"), 
     159                DoesNotEqual("<>", "DoesNotEqual"), 
     160                OnOrBefore("<=", "OnOrBefore"), 
     161                OnOrAfter(">=", "OnOrAfter"), 
    152162                Before("<", "Before"), 
    153163                After(">", "After");             
     
    168178         
    169179        public static enum Scope { 
    170                 MDIP("MDIP", "Marine Data Information Partnership (organisation now renamed MEDIN) "), 
    171                 NERC_DDC("NERC_DDC", "NERC Designated Data Centres"), 
    172                 NERC("NERC", "NERC (General)"), 
    173                 DPPP("DPPP", "Data Portals Project Provider ");          
     180                MDIP("MDIP", "MDIP"), 
     181                NERC_DDC("NERC_DDC", "NERC_DDC"), 
     182                NERC("NERC", "NERC"), 
     183                DPPP("DPPP", "DPPP");            
    174184                 
    175185                private final String fieldName; 
     
    187197        }        
    188198         
     199        public static enum SpatialOperator { 
     200                OVERLAP("Overlaps", "Overlaps"), 
     201                DOESNOTOVERLAP("DoesNotOverlap", "DoesNotOverlap"), 
     202                WITHIN("Within", "Within");              
     203                 
     204                private final String fieldName; 
     205                private final String fieldLabel; 
     206                SpatialOperator(String fieldName, String fieldLabel) { 
     207                        this.fieldName = fieldName; 
     208                        this.fieldLabel = fieldLabel; 
     209                } 
     210                public final String fieldName() { 
     211                        return fieldName; 
     212                } 
     213                public final String fieldLabel() { 
     214                        return fieldLabel; 
     215                }                
     216        } 
     217 
     218        public static enum SpatialReferenceSystem { 
     219                EPSG4326("EPSG4326", "EPSG4326");                
     220                 
     221                private final String fieldName; 
     222                private final String fieldLabel; 
     223                SpatialReferenceSystem(String fieldName, String fieldLabel) { 
     224                        this.fieldName = fieldName; 
     225                        this.fieldLabel = fieldLabel; 
     226                } 
     227                public final String fieldName() { 
     228                        return fieldName; 
     229                } 
     230                public final String fieldLabel() { 
     231                        return fieldLabel; 
     232                }                
     233        } 
     234         
     235        public static enum MetadataFormat { 
     236                DIF_9_4("DIF_9.4", "DIF_9.4"), 
     237                DC("DC", "DC"), 
     238                MEDIN_2_3("MEDIN_2.3", "MEDIN_2.3"), 
     239                ISO19115("ISO19115", "ISO19115");                
     240                 
     241                private final String fieldName; 
     242                private final String fieldLabel; 
     243                MetadataFormat(String fieldName, String fieldLabel) { 
     244                        this.fieldName = fieldName; 
     245                        this.fieldLabel = fieldLabel; 
     246                } 
     247                public final String fieldName() { 
     248                        return fieldName; 
     249                } 
     250                public final String fieldLabel() { 
     251                        return fieldLabel; 
     252                }                
     253        } 
     254         
     255        public static enum OriginalFormat { 
     256                DIF_9_4("DIF_9.4", "DIF_9.4"), 
     257                MEDIN_2_3("MEDIN_2.3", "MEDIN_2.3"), 
     258                ISO19115("ISO19115", "ISO19115");                
     259                 
     260                private final String fieldName; 
     261                private final String fieldLabel; 
     262                OriginalFormat(String fieldName, String fieldLabel) { 
     263                        this.fieldName = fieldName; 
     264                        this.fieldLabel = fieldLabel; 
     265                } 
     266                public final String fieldName() { 
     267                        return fieldName; 
     268                } 
     269                public final String fieldLabel() { 
     270                        return fieldLabel; 
     271                }                
     272        } 
     273         
     274        public static enum OriginalDocumentToTable { 
     275                DocumentId("dataset_start_date_nom", "originalDocumentId"), 
     276                OriginalDocumentFilename("original_document_filename", "originalDocumentFilename"),      
     277                DiscoveryId("discovery_id", "discoveryId"), 
     278                OriginalFormat("original_format", "originalFormat"), 
     279                OriginalFormatName("original_format_name", "originalFormatName"), 
     280                OriginalFormatVersion("original_format_version", "originalFormatVersion"), 
     281                DatacentreName("create_date", "datacentreName"), 
     282                DatasetName("dataset_name", "datasetName"), 
     283                DatasetAbstract("dataset_abstract", "datasetAbstract"), 
     284                DatasetMetadataUpdateDate("dataset_metadata_update_date", "datasetMetadataUpdateDate"), 
     285                DatasetMetadataCreationDate("dataset_metadata_creation_date", "datasetMetadataCreationDate"), 
     286                DatasetMetadataPublicationDate("dataset_metadata_publication_date", "datasetMetadataPublicationDate"), 
     287                DatasetStartDateNom("dataset_start_date_nom", "datasetStartDateNom"), 
     288                DatasetEndDateNom("dataset_end_date_nom", "datasetEndDateNom"), 
     289                OriginalDocument("original_document", "originalDocument"), 
     290                Authors("authors", "authors"), 
     291                Parameters("parameters", "parameters"), 
     292                ResourceType("resource_type", "resourceType"), 
     293                TopicCategory("topic_category", "topicCategory"), 
     294                Lineage("lineage", "lineage"), 
     295                LimitationsPublicAccess("limitations_public_access", "limitationsPublicAccess"), 
     296                DataOriginator("create_date", "dataOriginator"), 
     297                CreateDate("create_date", "createDate"), 
     298                UpdateDate("update_date", "updateDate"), 
     299                HarvestCount("harvest_count", "harvestCount"), 
     300                ResultsetCount("resultset_count", "resultsetCount"), 
     301                AccessCount("access_count", "accessCount"); 
     302                 
     303                private final String fieldName; 
     304                private final String odField; 
     305                OriginalDocumentToTable(String fieldName, String odField) { 
     306                        this.fieldName = fieldName; 
     307                        this.odField = odField; 
     308                } 
     309                public final String fieldName() { 
     310                        return fieldName; 
     311                } 
     312                public final String getOdField() { 
     313                        return odField; 
     314                }                
     315        }                
     316         
     317        /** 
     318         * Returns the {@link MetadataFormat} proper element 
     319         * for the given parameter. In the paramenter is <code>null</code> or 
     320         * not found the default value {@link MetadataFormat#MEDIN_2_3}} 
     321         * is returned 
     322         * @param label the reference label 
     323         * @return the proper {@link MetadataFormat} or the default value 
     324         * */ 
     325        public static MetadataFormat getMetadataFormat(String label) { 
     326                MetadataFormat type = MetadataFormat.MEDIN_2_3; 
     327                if (label != null) { 
     328                        for (MetadataFormat item : MetadataFormat.values()) { 
     329                                if(label.trim().equals(item.fieldLabel())) { 
     330                                        type = item; 
     331                                        break; 
     332                                } 
     333                        }        
     334                } 
     335                return type; 
     336        }        
     337         
     338        /** 
     339         * Returns the {@link OriginalFormat} proper element 
     340         * for the given parameter.  
     341         * @param label the reference label 
     342         * @return the proper {@link OriginalFormat} or <code>null</code>  
     343         * if the label does not exist 
     344         * */ 
     345        public static OriginalFormat getOriginalFormat(String label) { 
     346                OriginalFormat type = null; 
     347                if (label != null) { 
     348                        for (OriginalFormat item : OriginalFormat.values()) { 
     349                                if(label.trim().equals(item.fieldLabel())) { 
     350                                        type = item; 
     351                                        break; 
     352                                } 
     353                        }        
     354                } 
     355                return type; 
     356        }                
     357         
     358        /** 
     359         * Returns the {@link SpatialReferenceSystem} proper element 
     360         * for the given parameter. 
     361         * @param label the reference label 
     362         * @return the proper {@link SpatialReferenceSystem} or <code>null</code>  
     363         * if the label does not exist 
     364         * */ 
     365        public static SpatialReferenceSystem getSpatialReferenceSystem(String label) { 
     366                SpatialReferenceSystem type = null; 
     367                if (label != null) { 
     368                        for (SpatialReferenceSystem item : SpatialReferenceSystem.values()) { 
     369                                if(label.trim().equals(item.fieldLabel())) { 
     370                                        type = item; 
     371                                        break; 
     372                                } 
     373                        }        
     374                } 
     375                return type; 
     376        }        
     377         
     378        /** 
     379         * Returns the {@link SpatialOperator} proper element 
     380         * for the given parameter. 
     381         * @param label the operator label 
     382         * @return the proper {@link SpatialOperator} or <code>null</code>  
     383         * if the label does not exist 
     384         **/ 
     385        public static SpatialOperator getSpatialOperator(String label) { 
     386                SpatialOperator type = SpatialOperator.OVERLAP; 
     387                if (label != null) { 
     388                        for (SpatialOperator item : SpatialOperator.values()) { 
     389                                if(label.trim().equals(item.fieldLabel())) { 
     390                                        type = item; 
     391                                        break; 
     392                                } 
     393                        }        
     394                } 
     395                return type; 
     396        }                
     397         
    189398        /** 
    190399         * Returns the {@link Names} proper element 
    191          * for the given parameter. In the paramenter is <code>null</code> or 
    192          * not found the default value {@link TermTarget#FullText}} 
    193          * is returned 
    194          * @param label the name of the required termType. 
    195          * @return the proper {@link TermTarget} or the default value  
     400         * for the given parameter. 
     401         * @param label the name label 
     402         * @return the proper {@link Names} or <code>null</code>  
     403         * if the label does not exist 
    196404         * */ 
    197405        public static Names getNames(String label) { 
     
    199407                if (label != null) { 
    200408                        for (Names item : Names.values()) { 
    201                                 if(label.trim().equals(item.fieldLabel())) {file:///home/users/mnagni/workspace/MARINDiscoveryService/target/MedinDiscoveryService-0.0.1-SNAPSHOT.aar 
     409                                if(label.trim().equals(item.fieldLabel())) { 
    202410                                        type = item; 
    203411                                        break; 
     
    213421         * not found the default value {@link TermTarget#FullText}} 
    214422         * is returned 
    215          * @param label the name of the required termType. 
     423         * @param label the term label 
    216424         * @return the proper {@link TermTarget} or the default value  
    217425         * */ 
     
    232440         * Returns the {@link RecordDetail} proper element 
    233441         * for the given parameter. In the paramenter is <code>null</code> or 
    234          * not found the default value {@link RecordDetail#DocumentId}} 
     442         * not found the default value {@link RecordDetail#DocumentSimple}} 
    235443         * is returned 
    236          * @param label the name of the required detailType. 
     444         * @param label the detail label 
    237445         * @return the proper {@link RecordDetail} or the default value  
    238446         * */ 
     
    255463         * not found the default value {@link DateRangeTarget#TemporalCoverage}} 
    256464         * is returned 
    257          * @param label the name of the required termType. 
     465         * @param label the range label 
    258466         * @return the proper {@link DateRangeTarget} or the default value  
    259467         * */ 
     
    276484         * not found the default value {@link TemporalOperator#OnOrAfter}} 
    277485         * is returned 
    278          * @param label the name of the required termType. 
     486         * @param label the operator label 
    279487         * @return the proper {@link DateRangeTarget} or the default value  
    280488         * */ 
     
    292500        } 
    293501         
     502        /** 
     503         * Returns the {@link OrderByField} proper element 
     504         * for the given parameter. 
     505         * @param label the field label 
     506         * @return the proper {@link OrderByField} or <code>null</code>  
     507         * if the label does not exist 
     508         * */    
    294509        public static OrderByField getOrderByField(String fieldName){ 
    295510                OrderByField ret = null; 
     
    303518        } 
    304519         
     520        /** 
     521         * Returns the {@link OrderDirection} proper element 
     522         * for the given parameter. In the paramenter is <code>null</code> or 
     523         * not found the default value {@link OrderDirection#DESC}} 
     524         * is returned 
     525         * @param label the direction label 
     526         * @return the proper {@link OrderDirection} or the default value  
     527         * */    
    305528        public static OrderDirection getOrderDirection(String fieldName){ 
    306529                OrderDirection ret = OrderDirection.DESC; 
     
    314537        } 
    315538         
     539        /** 
     540         * Returns the {@link Scope} proper element 
     541         * for the given parameter. 
     542         * @param label the scope label 
     543         * @return the proper {@link Scope} or <code>null</code>  
     544         * if the label does not exist 
     545         * */ 
    316546        public static DiscoveryDictionary.Scope getScope(String fieldName){ 
    317547                Scope ret = null; 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/PresentAgent.java

    r6622 r6659  
    66import java.sql.ResultSet; 
    77import java.sql.SQLException; 
    8 import java.sql.Statement; 
    98import java.util.ArrayList; 
    109import java.util.Iterator; 
    1110import java.util.List; 
    1211 
    13 import ndg.common.MessageFormatter; 
    1412import ndg.common.NdgMessage; 
    1513import ndg.common.exception.NdgSQLException; 
     
    1715import ndg.services.discovery.medin.DiscoveryBasic; 
    1816import ndg.services.discovery.medin.DiscoveryDictionary; 
    19 import ndg.services.discovery.medin.DiscoveryDictionary.OrderByField; 
    20 import ndg.services.discovery.medin.DiscoveryDictionary.RecordDetail; 
     17import ndg.services.discovery.medin.DiscoveryDictionary.OriginalDocumentToTable; 
     18import ndg.services.discovery.medin.schema.RetrieveCriteriaType; 
     19import ndg.services.discovery.medin.schema.SearchType.SearchCriteria; 
    2120import ndg.services.jpa.OriginalDocument; 
    2221 
    2322import org.apache.log4j.Logger; 
    24  
    2523 
    2624/** 
     
    2927 * @author Maurizio Nagni <maurizio.nagni@stcf.ac.uk> 
    3028 **/ 
    31 public class PresentAgent { 
     29public class PresentAgent extends CommonMethods { 
    3230 
    3331        private static Logger logger = Logger.getLogger(SearchAgent.class.getName()); 
    34          
    35         /** 
    36          * Executes the search and returns a SearchSummary object 
    37          *  
    38          * @return SearchSummary object containing result of search 
    39          * @throws ResourceNotAvailable 
    40          *             if the <code>Connection</code> is not available 
    41          * @throws NdgSQLException 
    42          *             If a database access exception occurs 
    43          */ 
    44         private List<OriginalDocument> retrieveDocuments(Connection conn, List<String> documentsId, RecordDetail type) throws NdgSQLException { 
     32 
     33        private List<String> documentsId = new ArrayList<String>(); 
     34 
     35        @Override 
     36        List<OriginalDocument> loadResultSet(ResultSet rs) throws SQLException { 
    4537                List<OriginalDocument> ret = new ArrayList<OriginalDocument>(); 
    46                 if (documentsId == null || documentsId.size() == 0) 
    47                         return ret; 
    48                 Statement stat = null; 
    49                 ResultSet rs = null; 
    50                 String sqlQuery = assembleRetrieve(documentsId, type); 
    51                 NdgMessage msg = null; 
    52                 if (logger.isInfoEnabled()) { 
    53                         msg = new NdgMessage("sql.command", new Object[] { sqlQuery.toString() }); 
    54                         logger.info(getMsgFormatter().getFormattedText(msg)); 
    55                 } 
    56                 try { 
    57                         stat = conn.createStatement(); 
    58                         rs = stat.executeQuery(sqlQuery); 
    59                 } catch (SQLException e) { 
    60                         closeStatement(stat, rs); 
    61                         msg = new NdgMessage("sql.execution.error", new Object[] { sqlQuery }); 
    62                         throw new NdgSQLException(msg); 
    63                 } 
    64  
    6538                OriginalDocument item; 
    66  
    6739                if (rs != null) { 
    6840                        while (true) { 
     
    8254                        } 
    8355                } 
    84                 closeStatement(stat, rs); 
    8556                return ret; 
    8657        } 
    87          
    88         private String assembleRetrieve(List<String> documentsId, RecordDetail type) { 
    89  
    90                 StringBuffer sqlCmd = new StringBuffer("SELECT "); 
    91  
     58 
     59        @Override 
     60        void assembleSearchQuery(StringBuffer selectSQL, StringBuffer fromSQL, StringBuffer whereSQL, 
     61                        SearchCriteria criteria, RetrieveCriteriaType retrieveType) { 
     62 
     63                String customInfo = "original_document.authors, original_document.parameters, original_document.resource_type, original_document.topic_category, original_document.lineage, original_document.limitations_public_access, original_document.data_originator, original_document.original_format_name"; 
     64 
     65                String recDetail = retrieveType == null ? null : retrieveType.getRecordDetail(); 
     66                DiscoveryDictionary.RecordDetail detail = DiscoveryDictionary.getRecordDetails(recDetail); 
    9267                /** all the IFs should be revisited */ 
    93                 if (type.equals(DiscoveryDictionary.RecordDetail.DocumentSimple)) { 
    94                         sqlCmd.append(" original_document_filename"); 
    95                 } 
    96                 if (type.equals(DiscoveryDictionary.RecordDetail.DocumentBrief)) { 
    97                         sqlCmd.append(" original_document_filename, dataset_name"); 
    98                 } 
    99                 if (type.equals(DiscoveryDictionary.RecordDetail.DocumentSummary)) { 
    100                         sqlCmd.append(" original_document_filename, dataset_name, dataset_abstract"); 
    101                 } 
    102                 if (type.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) { 
    103                         sqlCmd.append(" original_document_filename, dataset_name, dataset_abstract, original_document"); 
    104                 } 
    105  
    106                 /* -----WHERE----- */ 
    107                 StringBuffer whereSQL = new StringBuffer(); 
    108                 whereSQL.append(" FROM original_document WHERE original_document_filename IN ("); 
     68                if (detail.equals(DiscoveryDictionary.RecordDetail.DocumentSimple)) { 
     69 
     70                } 
     71                if (detail.equals(DiscoveryDictionary.RecordDetail.DocumentBrief)) { 
     72                        checkFROMComma(selectSQL, false); 
     73                        selectSQL.append(" dataset_name, dataset_metadata_update_date, " + customInfo); 
     74                } 
     75                if (detail.equals(DiscoveryDictionary.RecordDetail.DocumentSummary)) { 
     76                        checkFROMComma(selectSQL, false); 
     77                        selectSQL.append(" dataset_name, dataset_abstract"); 
     78                } 
     79                if (detail.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) { 
     80                        checkFROMComma(selectSQL, false); 
     81                        selectSQL.append(" dataset_name, dataset_abstract, dataset_metadata_update_date, "      + customInfo); 
     82                } 
     83 
     84                checkWHERE_AND(whereSQL, false); 
     85                whereSQL.append(DiscoveryDictionary.ORIGINAL_DOCUMENT_TABLE); 
     86                whereSQL.append(".original_document_filename"); 
     87                whereSQL.append(" IN ("); 
    10988 
    11089                Iterator<String> iter = documentsId.iterator(); 
     
    11796                } 
    11897                whereSQL.append(") "); 
    119  
    120                 /* -----ORDER BY----- */ 
    121                 orderByHook(whereSQL, sqlCmd); 
    122                  
    123  
    124                 /* -- Append the FROM-WHERE clause to the SELECT command -- */ 
    125                 sqlCmd.append(whereSQL); 
    126                 return sqlCmd.toString(); 
    127         }        
     98                 
     99                /* ----- FORMAT ----- */ 
     100                String formType = retrieveType != null ? retrieveType.getRecordDetail() : null; 
     101                DiscoveryDictionary.RecordDetail details = DiscoveryDictionary.getRecordDetails(formType); 
     102                if (details.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) { 
     103                        String metaFormat = retrieveType == null ? null : retrieveType.getMetadataFormat(); 
     104                        preapareFormatCondition(selectSQL, fromSQL, whereSQL, metaFormat);       
     105                } 
     106        } 
     107 
     108        private void preapareFormatCondition(StringBuffer selectSQL, StringBuffer fromSQL, StringBuffer whereSQL, String format) { 
     109                DiscoveryDictionary.MetadataFormat docFormat = DiscoveryDictionary.getMetadataFormat(format); 
     110                 
     111                 
     112                checkFROMComma(selectSQL, false); 
     113                selectSQL.append(DiscoveryDictionary.TRANSFORMED_DOCUMENT_TABLE); 
     114                selectSQL.append(".transformed_document as "); 
     115                selectSQL.append(DiscoveryDictionary.FULL_DOCUMENT); 
     116                 
     117                checkFROMComma(fromSQL, false); 
     118                fromSQL.append(DiscoveryDictionary.TRANSFORMED_DOCUMENT_TABLE); 
     119                 
     120                checkWHERE_AND(whereSQL, false); 
     121                whereSQL.append(DiscoveryDictionary.TRANSFORMED_DOCUMENT_TABLE); 
     122                whereSQL.append(".transformed_format = '"); 
     123                whereSQL.append(DiscoveryDictionary.getMetadataFormat(format).fieldName()); 
     124                whereSQL.append("'"); 
     125                checkWHERE_AND(whereSQL, false); 
     126                whereSQL.append(DiscoveryDictionary.TRANSFORMED_DOCUMENT_TABLE); 
     127                whereSQL.append(".original_document_id = "); 
     128                whereSQL.append(DiscoveryDictionary.ORIGINAL_DOCUMENT_TABLE); 
     129                whereSQL.append(".original_document_id"); 
     130        } 
    128131         
    129         /** 
    130          * Allows the {@link SearchAgent} to override the orderBy method which is, 
    131          * actually, not used by the {@link PresentAgent}  
    132          **/ 
    133         void orderByHook(StringBuffer whereSQL, StringBuffer sqlCmd) {           
    134         } 
    135          
     132        private void prepareOrderBy(StringBuffer whereSQL, StringBuffer sqlCmd, RetrieveCriteriaType criteria) { 
     133                StringBuffer orderSQL = getOrderBy(criteria, sqlCmd); 
     134                /* -- Append the ORDER BY clause to the WHERE command -- */ 
     135                if (orderSQL.length() > 0) { 
     136                        whereSQL.append(" ORDER BY "); 
     137                        whereSQL.append(orderSQL); 
     138                } 
     139        } 
     140 
    136141        /** 
    137142         *  
     
    142147        private OriginalDocument fillMEDINSearchResult(ResultSet rs) throws SQLException { 
    143148                OriginalDocument od = new OriginalDocument(); 
    144  
    145                 if (columnExist(rs, "original_document_filename")) 
    146                         od.setOriginalDocumentFilename(rs.getString("original_document_filename")); 
    147  
    148                 if (columnExist(rs, "dataset_name")) 
    149                         od.setDatasetName(rs.getString("dataset_name")); 
    150  
    151                 if (columnExist(rs, "original_document")) 
    152                         od.setOriginalDocument(rs.getString("original_document")); 
    153  
    154                 if (columnExist(rs, "dataset_abstract")) 
    155                         od.setDatasetAbstract(rs.getString("dataset_abstract")); 
    156  
    157                 NdgMessage msg = new NdgMessage("invocation.error", new Object[] { "Field.get(result)" });                       
    158                 for (OrderByField order : DiscoveryDictionary.OrderByField.values()) { 
     149                /* 
     150                 * if (columnExist(rs, "original_document_filename")) 
     151                 * od.setOriginalDocumentFilename 
     152                 * (rs.getString("original_document_filename")); 
     153                 *  
     154                 * if (columnExist(rs, "dataset_name")) 
     155                 * od.setDatasetName(rs.getString("dataset_name")); 
     156                 *  
     157                 * if (columnExist(rs, "original_document")) 
     158                 * od.setOriginalDocument(rs.getString("original_document")); 
     159                 *  
     160                 * if (columnExist(rs, "dataset_abstract")) 
     161                 * od.setDatasetAbstract(rs.getString("dataset_abstract")); 
     162                 *  
     163                 * if (columnExist(rs, "dataset_abstract")) 
     164                 * od.setDatasetAbstract(rs.getString("dataset_abstract")); 
     165                 */ 
     166                NdgMessage msg = new NdgMessage("invocation.error", new Object[] { "Field.get(result)" }); 
     167                for (OriginalDocumentToTable order : DiscoveryDictionary.OriginalDocumentToTable.values()) { 
    159168                        if (columnExist(rs, order.fieldName())) 
    160169                                try { 
     
    162171                                        Class<?> type = field.getPropertyType(); 
    163172                                        if (String.class.isAssignableFrom(type)) { 
    164                                                 DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()).getWriteMethod().invoke(od, rs.getString(order.fieldName())); 
     173                                                DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()).getWriteMethod().invoke(od, 
     174                                                                rs.getString(order.fieldName())); 
    165175                                        } else if (java.sql.Timestamp.class.isAssignableFrom(type)) { 
    166                                                 DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()).getWriteMethod().invoke(od, rs.getTimestamp((order.fieldName())));                                   
    167                                         } else if (Integer.class.isAssignableFrom(type)) {               
    168                                                 field.getWriteMethod().invoke(od, rs.getString(rs.getInt((order.fieldName()))));                                                                                         
     176                                                DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()).getWriteMethod().invoke(od, 
     177                                                                rs.getTimestamp((order.fieldName()))); 
     178                                        } else if (Integer.class.isAssignableFrom(type)) { 
     179                                                field.getWriteMethod().invoke(od, rs.getString(rs.getInt((order.fieldName())))); 
    169180                                        } 
    170181                                } catch (IllegalArgumentException e) { 
     
    175186                                        logger.error(msg, e); 
    176187                                } 
    177                 }                
     188                } 
     189                if (columnExist(rs, DiscoveryDictionary.FULL_DOCUMENT)) 
     190                         od.setOriginalDocument(rs.getString(DiscoveryDictionary.FULL_DOCUMENT)); 
    178191                return od; 
    179192        } 
    180          
     193 
    181194        /** 
    182195         * Executes the search and returns a SearchSummary object 
     
    188201         *             if cannot access to the database 
    189202         */ 
    190         public List<OriginalDocument> doPresent(Connection conn, List<String> documentsId, RecordDetail type) throws NdgSQLException, ResourceNotAvailable { 
     203        public List<OriginalDocument> doPresent(Connection conn, List<String> documentsId, RetrieveCriteriaType type) 
     204                        throws NdgSQLException, ResourceNotAvailable { 
     205                if (documentsId == null || documentsId.size() == 0) 
     206                        return new ArrayList<OriginalDocument>(); 
     207                this.documentsId = documentsId; 
     208                String sqlQuery = assembleSearch(null, type); 
    191209                boolean commit = false; 
    192210                if (conn == null) { 
     
    194212                        commit = true; 
    195213                } 
    196                 List<OriginalDocument> searchResult = null; 
    197                 try { 
    198                         conn.setAutoCommit(false); 
    199                         searchResult = retrieveDocuments(conn, documentsId, type); 
    200                         commit = true; 
    201                 } catch (SQLException e) { 
    202                         // TODO Auto-generated catch block 
    203                         e.printStackTrace(); 
    204                 } finally { 
    205                         commitOrRollback(conn, commit); 
    206                 } 
     214                List<OriginalDocument> searchResult = executeSearch(conn, sqlQuery); 
    207215                return searchResult; 
    208216        } 
    209          
     217 
    210218        private boolean columnExist(ResultSet rs, String columnName) { 
    211219                boolean columnExist = false; 
     
    217225                return columnExist; 
    218226        } 
    219          
    220         /* ------- COMMON CODE TO MERGE ------- */ 
    221          
    222         private MessageFormatter getMsgFormatter() { 
    223                 return DiscoveryBasic.getInstance().getFormatter(); 
    224         } 
    225          
    226         private void commitOrRollback(Connection conn, boolean commit) { 
    227                 try { 
    228                         if (conn != null) { 
    229                                 if (commit) { 
    230                                         conn.commit(); 
    231                                 } else { 
    232                                         conn.rollback(); 
    233                                 } 
    234                         } 
    235                 } catch (Exception e) { 
    236                 } 
    237         } 
    238          
    239         private void closeStatement(Statement stat, ResultSet rs) { 
    240                 try { 
    241                         if (rs != null) 
    242                                 rs.close(); 
    243                 } catch (Exception e) { 
    244                 } 
    245                 try { 
    246                         if (stat != null) 
    247                                 stat.close(); 
    248                 } catch (Exception e) { 
    249                 } 
    250         } 
    251227} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/SearchAgent.java

    r6622 r6659  
    44import java.sql.ResultSet; 
    55import java.sql.SQLException; 
    6 import java.sql.Statement; 
    76import java.util.ArrayList; 
    87import java.util.List; 
    98 
    10 import ndg.common.MessageFormatter; 
    11 import ndg.common.NdgMessage; 
    129import ndg.common.exception.NdgSQLException; 
    1310import ndg.common.exception.ResourceNotAvailable; 
    14 import ndg.services.discovery.medin.DateRangeType; 
    15 import ndg.services.discovery.medin.DateValueType; 
    1611import ndg.services.discovery.medin.DiscoveryBasic; 
    1712import ndg.services.discovery.medin.DiscoveryDictionary; 
    18 import ndg.services.discovery.medin.OrderByType; 
    19 import ndg.services.discovery.medin.SearchType; 
    20 import ndg.services.discovery.medin.TemporalType; 
    21 import ndg.services.discovery.medin.TermSearchType; 
    2213import ndg.services.discovery.medin.DiscoveryDictionary.TemporalOperator; 
    23 import ndg.services.discovery.medin.SearchType.SearchCriteria; 
     14import ndg.services.discovery.medin.schema.BoundingBoxType; 
     15import ndg.services.discovery.medin.schema.DateRangeType; 
     16import ndg.services.discovery.medin.schema.DateValueType; 
     17import ndg.services.discovery.medin.schema.RetrieveCriteriaType; 
     18import ndg.services.discovery.medin.schema.SearchType; 
     19import ndg.services.discovery.medin.schema.SpatialType; 
     20import ndg.services.discovery.medin.schema.TemporalType; 
     21import ndg.services.discovery.medin.schema.TermSearchType; 
     22import ndg.services.discovery.medin.schema.SearchType.SearchCriteria; 
    2423import ndg.services.jpa.OriginalDocument; 
    2524 
    2625import org.apache.log4j.Logger; 
    27  
    28  
    2926 
    3027/** 
     
    3532 * @author Maurizio Nagni <maurizio.nagni@stcf.ac.uk> 
    3633 */ 
    37 public class SearchAgent { 
    38         public static final String FULL_TEXT_TERM_TYPE = "fullText"; 
    39         public static final String AUTHOR_TERM_TYPE = "author"; 
    40         public static final String PARAMETER_TERM_TYPE = "parameter"; 
     34public class SearchAgent extends CommonMethods { 
    4135 
    4236        private static Logger logger = Logger.getLogger(SearchAgent.class.getName()); 
     
    7872                        commit = true; 
    7973                } catch (SQLException e) { 
    80                         // TODO Auto-generated catch block 
    81                         e.printStackTrace(); 
     74                        // NdgMessage msg = new NdgMessage("sql.resultset.parsing.error", 
     75                        // new Object[] { sqlQuery }); 
     76                        throw new NdgSQLException(e); 
    8277                } finally { 
    8378                        commitOrRollback(conn, commit); 
     
    9388         *                available 
    9489         **/ 
    95         private List<OriginalDocument> searchDocuments(Connection conn, SearchCriteria criteria)  
    96                         throws NdgSQLException, ResourceNotAvailable { 
     90        private List<OriginalDocument> searchDocuments(Connection conn, SearchCriteria criteria) throws NdgSQLException, 
     91                        ResourceNotAvailable { 
    9792                List<OriginalDocument> res = new ArrayList<OriginalDocument>(); 
    98                 List<String> toFilter = executeSearch(conn, assembleSearch(criteria)); 
     93                List<String> toFilter = executeSearch(conn, assembleSearch(criteria, searchType.getRetrieveCriteria())); 
    9994 
    10095                /* -- sets the number of hits -- */ 
     
    105100 
    106101                long howMany = searchType.getHowMany(); 
    107                 if (howMany > 0) {                       
    108                         howMany = (toFilter.size() > howMany + start) ? howMany + start : toFilter.size() - start; 
     102                if (howMany > 0) { 
     103                        howMany = (toFilter.size() >= howMany + start) ? howMany + start : toFilter.size(); 
    109104                } else { 
    110105                        howMany = toFilter.size(); 
     
    112107 
    113108                toFilter = toFilter.subList((int) start, (int) howMany); 
    114                 PresentAgent present = new PresentAgent(){ 
    115                         void orderByHook(StringBuffer whereSQL, StringBuffer sqlCmd) { 
    116                                 StringBuffer orderSQL = getOrderBy(sqlCmd); 
    117                                 /* -- Append the ORDER BY clause to the WHERE command -- */ 
    118                                 if (orderSQL.length() > 0) { 
    119                                         whereSQL.append(" ORDER BY "); 
    120                                         whereSQL.append(orderSQL); 
    121                                 }        
    122                         } 
    123                 }; 
    124                 DiscoveryDictionary.RecordDetail type = DiscoveryDictionary.getRecordDetails("getDefault"); 
    125                 if (searchType.getRetrieveCriteria() != null) 
    126                         type = DiscoveryDictionary.getRecordDetails(searchType.getRetrieveCriteria().getRecordDetail()); 
    127  
    128                 res = present.doPresent(conn, toFilter, type); 
     109                PresentAgent present = new PresentAgent(); 
     110                res = present.doPresent(conn, toFilter, searchType.getRetrieveCriteria()); 
    129111                return res; 
    130112        } 
    131  
    132         /** 
    133          * Executes the search and returns a SearchSummary object 
    134          *  
    135          * @return SearchSummary object containing result of search 
    136          * @throws ResourceNotAvailable 
    137          *             if the <code>Connection</code> is not available 
    138          * @throws NdgSQLException 
    139          *             If a database access exception occurs 
    140          */ 
    141         private List<String> executeSearch(Connection conn, String sqlQuery) throws NdgSQLException { 
    142                 Statement stat = null; 
    143                 ResultSet rs = null; 
    144                 try { 
    145                         stat = conn.createStatement(); 
    146                         rs = stat.executeQuery(sqlQuery); 
    147                 } catch (SQLException e) { 
    148                         closeStatement(stat, rs); 
    149                         NdgMessage msg = new NdgMessage("sql.execution.error", 
    150  
    151                         new Object[] { sqlQuery }); 
    152                         throw new NdgSQLException(msg); 
    153                 } 
    154  
     113         
     114        @Override        
     115        List<String> loadResultSet(ResultSet rs) throws SQLException { 
    155116                List<String> ret = new ArrayList<String>(); 
    156                 try { 
    157                         while (rs != null && rs.next()) { 
    158                                 ret.add(rs.getString(1)); 
    159                         } 
    160                 } catch (SQLException e) { 
    161                         NdgMessage msg = new NdgMessage("sql.resultset.parsing.error", new Object[] { sqlQuery }); 
    162                         throw new NdgSQLException(msg); 
    163                 } finally { 
    164                         closeStatement(stat, rs); 
     117                while (rs != null && rs.next()) { 
     118                        ret.add(rs.getString(1)); 
    165119                } 
    166120                return ret; 
    167121        } 
    168  
    169         private String assembleSearch(SearchCriteria criteria) { 
     122         
     123        protected String assembleSearch(SearchCriteria criteria) { 
    170124 
    171125                // NB, we use the postgres text search function to do term searches 
     
    175129                StringBuffer whereSQL = new StringBuffer(); 
    176130 
    177                 fromSQL.append(" FROM original_document "); 
     131                fromSQL.append(" FROM "); 
     132                fromSQL.append(DiscoveryDictionary.ORIGINAL_DOCUMENT_TABLE); 
    178133 
    179134                // NB, historically, limited wildcard searches were possible with 
     
    192147                 */ 
    193148 
    194                 /* -- is a SpatialSearch? -- */ 
    195                 preapareSpatialSearch(fromSQL, whereSQL, criteria.getTermSearchArray()); 
    196  
    197                 /* -- is a TemporalSearch? -- */ 
    198                 preapareTemporalSearch(fromSQL, whereSQL, criteria.getTemporalSearch()); 
    199                  
    200                 /* -- has Scope request? -- */ 
    201                 preapareScopeSearch(fromSQL, whereSQL, searchType.getScopeArray());              
    202  
     149                assembleSearchQuery(sqlCmd, fromSQL, whereSQL,criteria, null); 
     150                                 
    203151                /* -----ORDER BY----- */ 
    204                 StringBuffer orderSQL = getOrderBy(sqlCmd); 
     152                StringBuffer orderSQL = getOrderBy(searchType.getRetrieveCriteria(), sqlCmd); 
    205153 
    206154                /* -- Append the ORDER BY clause to the WHERE command -- */ 
     
    210158                } 
    211159 
    212                 /* -- Append the FROM clause to the SELECT command -- */ 
    213                 sqlCmd.append(fromSQL); 
    214  
    215                 /* -- Append the WHERE clause to the FROM command -- */ 
    216                 if (whereSQL.length() > 0) 
    217                         sqlCmd.append(" WHERE "); 
    218                 sqlCmd.append(whereSQL); 
    219  
    220                 if (logger.isInfoEnabled()) 
    221                         logger.info("SQL query generated: " + sqlCmd); 
    222  
    223                 return sqlCmd.toString(); 
     160                /* -- Finally assemble the query -- */ 
     161                return assembleQuery(sqlCmd, fromSQL, whereSQL); 
     162        } 
     163 
     164        @Override 
     165        void assembleSearchQuery(StringBuffer sqlCmd, StringBuffer fromSQL, StringBuffer whereSQL, 
     166                        SearchCriteria criteria, RetrieveCriteriaType retrieveType) { 
     167                /* -- is a TermSearch? -- */ 
     168                preapareTermSearch(fromSQL, whereSQL, criteria.getTermSearchArray()); 
     169 
     170                /* -- is a SpatialSearch? -- */ 
     171                preapareSpatialSearch(fromSQL, whereSQL, criteria.getSpatialSearch()); 
     172 
     173                /* -- is a TemporalSearch? -- */ 
     174                preapareTemporalSearch(fromSQL, whereSQL, criteria.getTemporalSearch()); 
     175 
     176                /* -- has Scope request? -- */ 
     177                preapareScopeSearch(fromSQL, whereSQL, searchType.getScopeArray()); 
     178                 
     179                /* -- has an OriginalFormat request? -- */ 
     180                preapareOriginalFormatSearch(fromSQL, whereSQL, searchType.getOriginalFormat()); 
    224181        } 
    225182 
     
    319276 
    320277        /** 
    321          * Append to 'where' clause in sql statement, ensuring 'AND' joins are added 
    322          * where required 
    323          *  
    324          * @param whereSqlCmd 
    325          *            - StringBuffer holding sql statement 
    326          * @param clause 
    327          *            - string sql clause to add to buffer 
    328          */ 
    329         private void appendWhereClause(StringBuffer whereSqlCmd, String clause) { 
    330                 if (!(whereSqlCmd.toString().trim().length() == 0)) 
    331                         whereSqlCmd.append(" AND "); 
    332                 whereSqlCmd.append(clause); 
    333         } 
    334  
    335         /** 
    336          * If a term is found to contain wildcards, do some simple tidying of it to 
    337          * allow it is handled ok in the SQL query 
    338          */ 
    339         private String convertWildcardTerm(String term) { 
    340                 return term.replaceAll("\\*", ".*"); 
    341         } 
    342  
    343         /** 
    344278         * Prepare an INSERT sql statement to submit to Discovery DB to increment 
    345279         * resultsetAccess count 
     
    361295        } 
    362296 
    363         private MessageFormatter getMsgFormatter() { 
    364                 return DiscoveryBasic.getInstance().getFormatter(); 
    365         } 
    366  
    367         private void commitOrRollback(Connection conn, boolean commit) { 
    368                 try { 
    369                         if (conn != null) { 
    370                                 if (commit) { 
    371                                         conn.commit(); 
    372                                 } else { 
    373                                         conn.rollback(); 
    374                                 } 
    375                         } 
    376                 } catch (Exception e) { 
    377                 } 
    378         } 
    379  
    380         private void closeStatement(Statement stat, ResultSet rs) { 
    381                 try { 
    382                         if (rs != null) 
    383                                 rs.close(); 
    384                 } catch (Exception e) { 
    385                 } 
    386                 try { 
    387                         if (stat != null) 
    388                                 stat.close(); 
    389                 } catch (Exception e) { 
    390                 } 
    391         } 
    392  
    393         /** 
    394          * Return a properly build ORDER BY clause. The parameter sqlCmd represents 
    395          * the SELECT clause where the fields used by the ORDER BY clause have to be 
    396          * added. 
    397          * */ 
    398         private StringBuffer getOrderBy(StringBuffer sqlCmd) { 
    399                 StringBuffer orderSQL = new StringBuffer(); 
    400                 if (searchType.getRetrieveCriteria() != null && searchType.getRetrieveCriteria().getOrderByArray().length > 0) { 
    401                         // orderSQL.append(" ORDER BY "); 
    402                         for (OrderByType order : searchType.getRetrieveCriteria().getOrderByArray()) { 
    403  
    404                                 DiscoveryDictionary.OrderByField orderField = DiscoveryDictionary.getOrderByField(order 
    405                                                 .getOrderByField()); 
    406                                 if (orderField == null) 
    407                                         continue; 
    408  
    409                                 /* -- Append the field to the ORDER BY command -- */ 
    410                                 if (orderSQL.length() > 0) { 
    411                                         orderSQL.append(" ,"); 
    412                                 } 
    413                                 orderSQL.append(orderField.fieldName()); 
    414                                 /* -- Append the field to the SELECT command -- */ 
    415                                 if (sqlCmd.length() > 0) { 
    416                                         sqlCmd.append(" ,"); 
    417                                 } 
    418                                 sqlCmd.append(orderField.fieldName()); //may be check the field name? 
    419                                 if (order.getOrderByDirection() != null) { 
    420                                         DiscoveryDictionary.OrderDirection direction = DiscoveryDictionary.getOrderDirection(order 
    421                                                         .getOrderByDirection().toString()); 
    422                                         /* 
    423                                          * -- Append direction for the ORDER BY specific field -- 
    424                                          */ 
    425                                         orderSQL.append(" "); 
    426                                         orderSQL.append(direction.fieldName()); 
    427                                 } 
    428  
    429                         } 
    430                 } 
    431                 return orderSQL; 
    432         } 
    433  
    434         private void preapareSpatialSearch(StringBuffer fromSQL, StringBuffer whereSQL, TermSearchType[] termsType) { 
     297        private void preapareTermSearch(StringBuffer fromSQL, StringBuffer whereSQL, TermSearchType[] termsType) { 
    435298                if (termsType == null || termsType.length == 0) 
    436299                        return; 
     
    458321                        term = term.replaceAll("(\\bAND\\b)|(\\band\\b)|\\+", "&"); 
    459322                        term = term.replaceAll("(\\bOR\\b)|(\\bor\\b)|\\|", "|"); 
    460                         term = term.replaceAll("(\\bNOT\\b)|(\\bnot\\b)\\-", "!"); 
    461  
     323                        term = term.replaceAll("(\\bNOT\\b)|(\\bnot\\b)|\\-", "!"); 
     324                        term = term.replaceAll("(\\B\\\\&\\B\\s+)|(\\s+\\B\\\\!\\B)|(\\b\\s+\\b)", "|"); 
    462325                        /* -- appends the terms (FROM part) -- */ 
    463326                        checkFROMComma(fromSQL, false); 
     
    486349                boolean secondPass = false; 
    487350 
     351                TemporalOperator operator = null; 
    488352                if (!rangeTarget.equals(DiscoveryDictionary.DateRangeTarget.TemporalCoverage)) { 
    489353                        for (DateValueType dataValue : dateValues) { 
    490354                                checkWHERE_AND(whereSQL, secondPass); 
    491                                 TemporalOperator operator = DiscoveryDictionary.getTemporalOperator(dataValue.getTemporalOperator()); 
     355                                operator = DiscoveryDictionary.getTemporalOperator(dataValue.getTemporalOperator()); 
    492356                                whereSQL.append(" " + rangeTarget.fieldName()); 
    493357                                whereSQL.append(" " + operator.fieldName()); 
    494                                 whereSQL.append(" " + dataValue.getDateValue1()); 
     358                                whereSQL.append(" '" + dataValue.getDateValue1() + "' "); 
    495359                                secondPass = true; 
    496360                        } 
    497361                } else { 
    498362                        checkFROMComma(fromSQL, false); 
    499                         fromSQL.append(" temporal_data"); 
    500                          
    501                         checkWHERE_AND(fromSQL, false); 
    502                         whereSQL.append(" original_document.id == temporal_data.original_document_id "); 
    503                         whereSQL.append(" AND "); 
    504                          
     363                        fromSQL.append(DiscoveryDictionary.TEMPORAL_DATA_TABLE); 
     364 
     365                        checkWHERE_AND(whereSQL, false); 
     366                        whereSQL.append(DiscoveryDictionary.ORIGINAL_DOCUMENT_TABLE); 
     367                        whereSQL.append(".original_document_id = " + DiscoveryDictionary.TEMPORAL_DATA_TABLE 
     368                                        + ".original_document_id "); 
     369 
    505370                        secondPass = false; 
    506371                        for (DateValueType dataValue : dateValues) { 
    507372                                checkWHERE_AND(whereSQL, secondPass); 
    508                                 TemporalOperator operator = DiscoveryDictionary.getTemporalOperator(dataValue.getTemporalOperator()); 
    509                                 whereSQL.append(" temporal_data.start_time "); 
    510                                 whereSQL.append(" " + operator.fieldName()); 
    511                                 whereSQL.append(dataValue.getDateValue1()); 
    512                                 whereSQL.append(" AND "); 
    513                                 whereSQL.append(" temporal_data.end_time "); 
    514                                 whereSQL.append(" " + operator.fieldName()); 
    515                                 whereSQL.append(dataValue.getDateValue1() + " "); 
     373                                operator = DiscoveryDictionary.getTemporalOperator(dataValue.getTemporalOperator()); 
     374                                if (!secondPass) { 
     375                                        whereSQL.append(" " + DiscoveryDictionary.TEMPORAL_DATA_TABLE); 
     376                                        whereSQL.append(".start_time "); 
     377                                        whereSQL.append(" " + operator.fieldName()); 
     378                                        whereSQL.append(" '" + dataValue.getDateValue1() + "' "); 
     379                                } else { 
     380                                        whereSQL.append(" " + DiscoveryDictionary.TEMPORAL_DATA_TABLE); 
     381                                        whereSQL.append(".end_time "); 
     382                                        whereSQL.append(" " + operator.fieldName()); 
     383                                        whereSQL.append(dataValue.getDateValue1() + " "); 
     384                                } 
    516385                                secondPass = true; 
    517386                        } 
    518387                } 
    519  
     388        } 
     389 
     390        private void preapareSpatialSearch(StringBuffer fromSQL, StringBuffer whereSQL, SpatialType spatialType) { 
     391                if (spatialType == null || spatialType.getBoundingBox() == null) 
     392                        return; 
     393 
     394                DiscoveryDictionary.SpatialOperator spatialOperator = DiscoveryDictionary.getSpatialOperator(null); 
     395                DiscoveryDictionary.SpatialReferenceSystem spatialReferenceSystem = DiscoveryDictionary 
     396                                .getSpatialReferenceSystem(null); 
     397 
     398                if (spatialType.getSpatialOperator() != null) 
     399                        spatialOperator = DiscoveryDictionary.getSpatialOperator(spatialType.getSpatialOperator()); 
     400 
     401                if (spatialType.getSpatialReferenceSystem() != null) 
     402                        spatialReferenceSystem = DiscoveryDictionary.getSpatialReferenceSystem(spatialType 
     403                                        .getSpatialReferenceSystem()); 
     404 
     405                BoundingBoxType bb = spatialType.getBoundingBox(); 
     406                String bbox = " SetSRID('BOX3D(" + bb.getLimitWest() + " " + bb.getLimitSouth() + ", " + bb.getLimitWest() 
     407                                + " " + bb.getLimitNorth() + ")'::box3d, 4326)"; 
     408 
     409                checkFROMComma(fromSQL, false); 
     410                fromSQL.append(DiscoveryDictionary.SPATIAL_DATA_TABLE); 
     411 
     412                checkWHERE_AND(whereSQL, false); 
     413                String spatialPart = DiscoveryDictionary.SPATIAL_DATA_TABLE + ".geometry "; 
     414                if (spatialOperator.equals(DiscoveryDictionary.SpatialOperator.OVERLAP)) { 
     415                        whereSQL.append(spatialPart); 
     416                        whereSQL.append(" && "); 
     417                } else if (spatialOperator.equals(DiscoveryDictionary.SpatialOperator.WITHIN)) { 
     418                        whereSQL.append(spatialPart); 
     419                        whereSQL.append(" @ "); 
     420                } else if (spatialOperator.equals(DiscoveryDictionary.SpatialOperator.DOESNOTOVERLAP)) { 
     421                        whereSQL.append(" NOT "); 
     422                        whereSQL.append(spatialPart); 
     423                        whereSQL.append(" && "); 
     424                } 
     425                whereSQL.append(bbox); 
     426 
     427                checkWHERE_AND(whereSQL, false); 
     428                whereSQL.append(DiscoveryDictionary.ORIGINAL_DOCUMENT_TABLE); 
     429                whereSQL.append(".original_document_id = "); 
     430                whereSQL.append(DiscoveryDictionary.SPATIAL_DATA_TABLE); 
     431                whereSQL.append(".original_document_id "); 
    520432        } 
    521433         
     
    524436                        return; 
    525437 
    526                         /* -- appends the terms (FROM part) -- */ 
    527                         checkFROMComma(fromSQL, false); 
    528                         fromSQL.append(" to_tsquery("); 
    529                         boolean secondPass = false; 
    530                         for (String scopeLabel : scopes) { 
    531                                 DiscoveryDictionary.Scope scope = DiscoveryDictionary.getScope(scopeLabel); 
    532                                 if (logger.isDebugEnabled()) { 
    533                                         logger.debug("Scope: " + scope); 
    534                                 } 
    535                                 if (secondPass)  
    536                                         whereSQL.append(" & "); 
    537                                 fromSQL.append(" '" + scope.fieldName() + "' "); 
     438                /* -- appends the terms (FROM part) -- */ 
     439                checkFROMComma(fromSQL, false); 
     440                fromSQL.append(" to_tsquery("); 
     441                boolean secondPass = false; 
     442                for (String scopeLabel : scopes) { 
     443                        DiscoveryDictionary.Scope scope = DiscoveryDictionary.getScope(scopeLabel); 
     444                        if (logger.isDebugEnabled()) { 
     445                                logger.debug("Scope: " + scope); 
    538446                        } 
    539                         fromSQL.append(") AS scopeQuery "); 
    540                          
    541                         checkWHERE_AND(whereSQL, false); 
    542                         whereSQL.append(" scopeQuery @@ (scope_ts_vector) "); 
    543  
    544  
    545                          
    546         }        
    547          
    548         /** 
    549          * Appends a comma to the given <code>StringBuffer</code> if 
    550          * <ul> 
    551          * <li> secondPass is <code>true</code></li> 
    552          * <li> secondPass is <code>false</code> AND <code>sb</code>'s length &gt 0 </li>  
    553          * </ul> 
    554          **/ 
    555         private void checkFROMComma(StringBuffer sb, boolean secondPass) { 
    556                 if (secondPass) { 
    557                         sb.append(", "); 
    558                 } else { 
    559                         if (sb.length() > 0) 
    560                                 sb.append(", "); 
    561                 } 
    562         } 
    563          
    564         /** 
    565          * Appends an "AND" to the given <code>StringBuffer</code> if 
    566          * <ul> 
    567          * <li> secondPass is <code>true</code></li> 
    568          * or 
    569          * <li> secondPass is <code>false</code> AND <code>sb</code>'s length &gt 0 </li>  
    570          * </ul> 
    571          **/     
    572         private void checkWHERE_AND(StringBuffer sb, boolean secondPass) { 
    573                 if (secondPass) { 
    574                         sb.append(" AND "); 
    575                 } else { 
    576                         if (sb.length() > 0) 
    577                                 sb.append(" AND "); 
    578                 } 
     447                        if (secondPass) 
     448                                whereSQL.append(" & "); 
     449                        fromSQL.append(" '" + scope.fieldName() + "' "); 
     450                } 
     451                fromSQL.append(") AS scopeQuery "); 
     452 
     453                checkWHERE_AND(whereSQL, false); 
     454                whereSQL.append(" scopeQuery @@ (scope_ts_vector) "); 
     455 
     456        } 
     457 
     458        void preapareOriginalFormatSearch(StringBuffer fromSQL, StringBuffer whereSQL, String originalFormat) { 
     459                if (originalFormat == null)  
     460                        return; 
     461                DiscoveryDictionary.OriginalFormat format = DiscoveryDictionary.getOriginalFormat(originalFormat); 
     462                checkWHERE_AND(whereSQL, false); 
     463                whereSQL.append(DiscoveryDictionary.ORIGINAL_DOCUMENT_TABLE); 
     464                whereSQL.append(".original_format = '"); 
     465                whereSQL.append(format.fieldName()); 
     466                whereSQL.append("' "); 
    579467        } 
    580468} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/jpa/OriginalDocument.java

    r6504 r6659  
    11package ndg.services.jpa; 
    22 
    3 import java.io.Serializable; 
    43import java.sql.Timestamp; 
    54 
    65 
    7 /** 
    8  * The persistent class for the original_document database table. 
    9  * Generated by a JPA enabled application. May be in future this  
    10  * will be a more general solution for the DB access. 
    11  *  
    12  */ 
    13 public class OriginalDocument implements Serializable { 
    14         private static final long serialVersionUID = 1L; 
     6public class OriginalDocument { 
    157 
    168        private Integer originalDocumentId; 
    179 
     10        private String originalDocumentFilename; 
     11 
     12        private String discoveryId; 
     13 
     14        private String originalFormat; 
     15 
     16        private String originalFormatName; 
     17 
     18        private String originalFormatVersion; 
     19 
     20        private String datacentreName; 
     21 
     22        private String datasetName; 
     23 
     24        private String datasetAbstract; 
     25 
     26        private Timestamp datasetMetadataUpdateDate; 
     27 
     28        private Timestamp datasetMetadataCreationDate; 
     29 
     30        private Timestamp datasetMetadataPublicationDate; 
     31 
     32        private Timestamp datasetStartDateNom; 
     33 
     34        private Timestamp datasetEndDateNom; 
     35 
     36        private String originalDocument; 
     37 
     38        private Object documentTsVector; 
     39 
     40        private String authors; 
     41 
     42        private Object authorsTsVector; 
     43 
     44        private String parameters; 
     45 
     46        private Object parametersTsVector; 
     47 
     48        private String resourceType; 
     49 
     50        private Object resourceTypeTsVector; 
     51 
     52        private String topicCategory; 
     53 
     54        private Object topicCategoryTsVector; 
     55 
     56        private String lineage; 
     57 
     58        private Object lineageTsVector; 
     59 
     60        private String limitationsPublicAccess; 
     61 
     62        private Object limitationsPublicAccessTsVector; 
     63 
     64        private String dataOriginator; 
     65 
     66        private Object dataOriginatorTsvector; 
     67 
     68        private Object scopeTsVector; 
     69 
     70        private Timestamp createDate; 
     71 
     72        private Timestamp updateDate; 
     73 
     74        private Integer harvestCount; 
     75 
     76        private Integer resultsetCount; 
     77 
    1878        private Integer accessCount; 
    1979 
    20         private Object authorsTsVector; 
    21  
    22         private Timestamp createDate; 
    23  
    24         private String datacentreName; 
    25  
    26         private String datasetAbstract; 
    27  
    28         private Timestamp datasetEndDateNom; 
    29  
    30         private Timestamp datasetMetadataUpdateDate; 
    31  
    32         private String datasetName; 
    33  
    34         private Timestamp datasetStartDateNom; 
    35  
    36         private String discoveryId; 
    37  
    38         private Object documentTsVector; 
    39  
    40         private Integer harvestCount; 
    41  
    42         private String medinVar1; 
    43  
    44         private String medinVar2; 
    45  
    46         private String medinVar3; 
    47  
    48         private String medinVar4; 
    49  
    50         private String medinVar5; 
    51  
    52         private String originalDocument; 
    53  
    54         private String originalDocumentFilename; 
    55  
    56         private String originalFormat; 
    57  
    58         private Object parametersTsVector; 
    59  
    60         private Integer resultsetCount; 
    61  
    6280        private Integer scn; 
    6381 
    64         private Object scopeTsVector; 
    65  
    66         private Timestamp updateDate; 
    67  
    68     public OriginalDocument() { 
    69     } 
     82        public OriginalDocument() { 
     83                super(); 
     84        } 
    7085 
    7186        public Integer getOriginalDocumentId() { 
     
    7792        } 
    7893 
     94        public String getOriginalDocumentFilename() { 
     95                return this.originalDocumentFilename; 
     96        } 
     97 
     98        public void setOriginalDocumentFilename(String originalDocumentFilename) { 
     99                this.originalDocumentFilename = originalDocumentFilename; 
     100        } 
     101 
     102        public String getDiscoveryId() { 
     103                return this.discoveryId; 
     104        } 
     105 
     106        public void setDiscoveryId(String discoveryId) { 
     107                this.discoveryId = discoveryId; 
     108        } 
     109 
     110        public String getOriginalFormat() { 
     111                return this.originalFormat; 
     112        } 
     113 
     114        public void setOriginalFormat(String originalFormat) { 
     115                this.originalFormat = originalFormat; 
     116        } 
     117 
     118        public String getOriginalFormatName() { 
     119                return this.originalFormatName; 
     120        } 
     121 
     122        public void setOriginalFormatName(String originalFormatName) { 
     123                this.originalFormatName = originalFormatName; 
     124        } 
     125 
     126        public String getOriginalFormatVersion() { 
     127                return this.originalFormatVersion; 
     128        } 
     129 
     130        public void setOriginalFormatVersion(String originalFormatVersion) { 
     131                this.originalFormatVersion = originalFormatVersion; 
     132        } 
     133 
     134        public String getDatacentreName() { 
     135                return this.datacentreName; 
     136        } 
     137 
     138        public void setDatacentreName(String datacentreName) { 
     139                this.datacentreName = datacentreName; 
     140        } 
     141 
     142        public String getDatasetName() { 
     143                return this.datasetName; 
     144        } 
     145 
     146        public void setDatasetName(String datasetName) { 
     147                this.datasetName = datasetName; 
     148        } 
     149 
     150        public String getDatasetAbstract() { 
     151                return this.datasetAbstract; 
     152        } 
     153 
     154        public void setDatasetAbstract(String datasetAbstract) { 
     155                this.datasetAbstract = datasetAbstract; 
     156        } 
     157 
     158        public Timestamp getDatasetMetadataUpdateDate() { 
     159                return this.datasetMetadataUpdateDate; 
     160        } 
     161 
     162        public void setDatasetMetadataUpdateDate(Timestamp datasetMetadataUpdateDate) { 
     163                this.datasetMetadataUpdateDate = datasetMetadataUpdateDate; 
     164        } 
     165 
     166        public Timestamp getDatasetMetadataCreationDate() { 
     167                return this.datasetMetadataCreationDate; 
     168        } 
     169 
     170        public void setDatasetMetadataCreationDate(Timestamp datasetMetadataCreationDate) { 
     171                this.datasetMetadataCreationDate = datasetMetadataCreationDate; 
     172        } 
     173 
     174        public Timestamp getDatasetMetadataPublicationDate() { 
     175                return this.datasetMetadataPublicationDate; 
     176        } 
     177 
     178        public void setDatasetMetadataPublicationDate(Timestamp datasetMetadataPublicationDate) { 
     179                this.datasetMetadataPublicationDate = datasetMetadataPublicationDate; 
     180        } 
     181 
     182        public Timestamp getDatasetStartDateNom() { 
     183                return this.datasetStartDateNom; 
     184        } 
     185 
     186        public void setDatasetStartDateNom(Timestamp datasetStartDateNom) { 
     187                this.datasetStartDateNom = datasetStartDateNom; 
     188        } 
     189 
     190        public Timestamp getDatasetEndDateNom() { 
     191                return this.datasetEndDateNom; 
     192        } 
     193 
     194        public void setDatasetEndDateNom(Timestamp datasetEndDateNom) { 
     195                this.datasetEndDateNom = datasetEndDateNom; 
     196        } 
     197 
     198        public String getOriginalDocument() { 
     199                return this.originalDocument; 
     200        } 
     201 
     202        public void setOriginalDocument(String originalDocument) { 
     203                this.originalDocument = originalDocument; 
     204        } 
     205 
     206        public Object getDocumentTsVector() { 
     207                return this.documentTsVector; 
     208        } 
     209 
     210        public void setDocumentTsVector(Object documentTsVector) { 
     211                this.documentTsVector = documentTsVector; 
     212        } 
     213 
     214        public String getAuthors() { 
     215                return this.authors; 
     216        } 
     217 
     218        public void setAuthors(String authors) { 
     219                this.authors = authors; 
     220        } 
     221 
     222        public Object getAuthorsTsVector() { 
     223                return this.authorsTsVector; 
     224        } 
     225 
     226        public void setAuthorsTsVector(Object authorsTsVector) { 
     227                this.authorsTsVector = authorsTsVector; 
     228        } 
     229 
     230        public String getParameters() { 
     231                return this.parameters; 
     232        } 
     233 
     234        public void setParameters(String parameters) { 
     235                this.parameters = parameters; 
     236        } 
     237 
     238        public Object getParametersTsVector() { 
     239                return this.parametersTsVector; 
     240        } 
     241 
     242        public void setParametersTsVector(Object parametersTsVector) { 
     243                this.parametersTsVector = parametersTsVector; 
     244        } 
     245 
     246        public String getResourceType() { 
     247                return this.resourceType; 
     248        } 
     249 
     250        public void setResourceType(String resourceType) { 
     251                this.resourceType = resourceType; 
     252        } 
     253 
     254        public Object getResourceTypeTsVector() { 
     255                return this.resourceTypeTsVector; 
     256        } 
     257 
     258        public void setResourceTypeTsVector(Object resourceTypeTsVector) { 
     259                this.resourceTypeTsVector = resourceTypeTsVector; 
     260        } 
     261 
     262        public String getTopicCategory() { 
     263                return this.topicCategory; 
     264        } 
     265 
     266        public void setTopicCategory(String topicCategory) { 
     267                this.topicCategory = topicCategory; 
     268        } 
     269 
     270        public Object getTopicCategoryTsVector() { 
     271                return this.topicCategoryTsVector; 
     272        } 
     273 
     274        public void setTopicCategoryTsVector(Object topicCategoryTsVector) { 
     275                this.topicCategoryTsVector = topicCategoryTsVector; 
     276        } 
     277 
     278        public String getLineage() { 
     279                return this.lineage; 
     280        } 
     281 
     282        public void setLineage(String lineage) { 
     283                this.lineage = lineage; 
     284        } 
     285 
     286        public Object getLineageTsVector() { 
     287                return this.lineageTsVector; 
     288        } 
     289 
     290        public void setLineageTsVector(Object lineageTsVector) { 
     291                this.lineageTsVector = lineageTsVector; 
     292        } 
     293 
     294        public String getLimitationsPublicAccess() { 
     295                return this.limitationsPublicAccess; 
     296        } 
     297 
     298        public void setLimitationsPublicAccess(String limitationsPublicAccess) { 
     299                this.limitationsPublicAccess = limitationsPublicAccess; 
     300        } 
     301 
     302        public Object getLimitationsPublicAccessTsVector() { 
     303                return this.limitationsPublicAccessTsVector; 
     304        } 
     305 
     306        public void setLimitationsPublicAccessTsVector(Object limitationsPublicAccessTsVector) { 
     307                this.limitationsPublicAccessTsVector = limitationsPublicAccessTsVector; 
     308        } 
     309 
     310        public String getDataOriginator() { 
     311                return this.dataOriginator; 
     312        } 
     313 
     314        public void setDataOriginator(String dataOriginator) { 
     315                this.dataOriginator = dataOriginator; 
     316        } 
     317 
     318        public Object getDataOriginatorTsvector() { 
     319                return this.dataOriginatorTsvector; 
     320        } 
     321 
     322        public void setDataOriginatorTsvector(Object dataOriginatorTsvector) { 
     323                this.dataOriginatorTsvector = dataOriginatorTsvector; 
     324        } 
     325 
     326        public Object getScopeTsVector() { 
     327                return this.scopeTsVector; 
     328        } 
     329 
     330        public void setScopeTsVector(Object scopeTsVector) { 
     331                this.scopeTsVector = scopeTsVector; 
     332        } 
     333 
     334        public Timestamp getCreateDate() { 
     335                return this.createDate; 
     336        } 
     337 
     338        public void setCreateDate(Timestamp createDate) { 
     339                this.createDate = createDate; 
     340        } 
     341 
     342        public Timestamp getUpdateDate() { 
     343                return this.updateDate; 
     344        } 
     345 
     346        public void setUpdateDate(Timestamp updateDate) { 
     347                this.updateDate = updateDate; 
     348        } 
     349 
     350        public Integer getHarvestCount() { 
     351                return this.harvestCount; 
     352        } 
     353 
     354        public void setHarvestCount(Integer harvestCount) { 
     355                this.harvestCount = harvestCount; 
     356        } 
     357 
     358        public Integer getResultsetCount() { 
     359                return this.resultsetCount; 
     360        } 
     361 
     362        public void setResultsetCount(Integer resultsetCount) { 
     363                this.resultsetCount = resultsetCount; 
     364        } 
     365 
    79366        public Integer getAccessCount() { 
    80367                return this.accessCount; 
     
    85372        } 
    86373 
    87         public Object getAuthorsTsVector() { 
    88                 return this.authorsTsVector; 
    89         } 
    90  
    91         public void setAuthorsTsVector(Object authorsTsVector) { 
    92                 this.authorsTsVector = authorsTsVector; 
    93         } 
    94  
    95         public Timestamp getCreateDate() { 
    96                 return this.createDate; 
    97         } 
    98  
    99         public void setCreateDate(Timestamp createDate) { 
    100                 this.createDate = createDate; 
    101         } 
    102  
    103         public String getDatacentreName() { 
    104                 return this.datacentreName; 
    105         } 
    106  
    107         public void setDatacentreName(String datacentreName) { 
    108                 this.datacentreName = datacentreName; 
    109         } 
    110  
    111         public String getDatasetAbstract() { 
    112                 return this.datasetAbstract; 
    113         } 
    114  
    115         public void setDatasetAbstract(String datasetAbstract) { 
    116                 this.datasetAbstract = datasetAbstract; 
    117         } 
    118  
    119         public Timestamp getDatasetEndDateNom() { 
    120                 return this.datasetEndDateNom; 
    121         } 
    122  
    123         public void setDatasetEndDateNom(Timestamp datasetEndDateNom) { 
    124                 this.datasetEndDateNom = datasetEndDateNom; 
    125         } 
    126  
    127         public Timestamp getDatasetMetadataUpdateDate() { 
    128                 return this.datasetMetadataUpdateDate; 
    129         } 
    130  
    131         public void setDatasetMetadataUpdateDate(Timestamp datasetMetadataUpdateDate) { 
    132                 this.datasetMetadataUpdateDate = datasetMetadataUpdateDate; 
    133         } 
    134  
    135         public String getDatasetName() { 
    136                 return this.datasetName; 
    137         } 
    138  
    139         public void setDatasetName(String datasetName) { 
    140                 this.datasetName = datasetName; 
    141         } 
    142  
    143         public Timestamp getDatasetStartDateNom() { 
    144                 return this.datasetStartDateNom; 
    145         } 
    146  
    147         public void setDatasetStartDateNom(Timestamp datasetStartDateNom) { 
    148                 this.datasetStartDateNom = datasetStartDateNom; 
    149         } 
    150  
    151         public String getDiscoveryId() { 
    152                 return this.discoveryId; 
    153         } 
    154  
    155         public void setDiscoveryId(String discoveryId) { 
    156                 this.discoveryId = discoveryId; 
    157         } 
    158  
    159         public Object getDocumentTsVector() { 
    160                 return this.documentTsVector; 
    161         } 
    162  
    163         public void setDocumentTsVector(Object documentTsVector) { 
    164                 this.documentTsVector = documentTsVector; 
    165         } 
    166  
    167         public Integer getHarvestCount() { 
    168                 return this.harvestCount; 
    169         } 
    170  
    171         public void setHarvestCount(Integer harvestCount) { 
    172                 this.harvestCount = harvestCount; 
    173         } 
    174  
    175         public String getMedinVar1() { 
    176                 return this.medinVar1; 
    177         } 
    178  
    179         public void setMedinVar1(String medinVar1) { 
    180                 this.medinVar1 = medinVar1; 
    181         } 
    182  
    183         public String getMedinVar2() { 
    184                 return this.medinVar2; 
    185         } 
    186  
    187         public void setMedinVar2(String medinVar2) { 
    188                 this.medinVar2 = medinVar2; 
    189         } 
    190  
    191         public String getMedinVar3() { 
    192                 return this.medinVar3; 
    193         } 
    194  
    195         public void setMedinVar3(String medinVar3) { 
    196                 this.medinVar3 = medinVar3; 
    197         } 
    198  
    199         public String getMedinVar4() { 
    200                 return this.medinVar4; 
    201         } 
    202  
    203         public void setMedinVar4(String medinVar4) { 
    204                 this.medinVar4 = medinVar4; 
    205         } 
    206  
    207         public String getMedinVar5() { 
    208                 return this.medinVar5; 
    209         } 
    210  
    211         public void setMedinVar5(String medinVar5) { 
    212                 this.medinVar5 = medinVar5; 
    213         } 
    214  
    215         public String getOriginalDocument() { 
    216                 return this.originalDocument; 
    217         } 
    218  
    219         public void setOriginalDocument(String originalDocument) { 
    220                 this.originalDocument = originalDocument; 
    221         } 
    222  
    223         public String getOriginalDocumentFilename() { 
    224                 return this.originalDocumentFilename; 
    225         } 
    226  
    227         public void setOriginalDocumentFilename(String originalDocumentFilename) { 
    228                 this.originalDocumentFilename = originalDocumentFilename; 
    229         } 
    230  
    231         public String getOriginalFormat() { 
    232                 return this.originalFormat; 
    233         } 
    234  
    235         public void setOriginalFormat(String originalFormat) { 
    236                 this.originalFormat = originalFormat; 
    237         } 
    238  
    239         public Object getParametersTsVector() { 
    240                 return this.parametersTsVector; 
    241         } 
    242  
    243         public void setParametersTsVector(Object parametersTsVector) { 
    244                 this.parametersTsVector = parametersTsVector; 
    245         } 
    246  
    247         public Integer getResultsetCount() { 
    248                 return this.resultsetCount; 
    249         } 
    250  
    251         public void setResultsetCount(Integer resultsetCount) { 
    252                 this.resultsetCount = resultsetCount; 
    253         } 
    254  
    255374        public Integer getScn() { 
    256375                return this.scn; 
     
    260379                this.scn = scn; 
    261380        } 
    262  
    263         public Object getScopeTsVector() { 
    264                 return this.scopeTsVector; 
    265         } 
    266  
    267         public void setScopeTsVector(Object scopeTsVector) { 
    268                 this.scopeTsVector = scopeTsVector; 
    269         } 
    270  
    271         public Timestamp getUpdateDate() { 
    272                 return this.updateDate; 
    273         } 
    274  
    275         public void setUpdateDate(Timestamp updateDate) { 
    276                 this.updateDate = updateDate; 
    277         } 
    278  
    279381} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/resources/service.properties

    r6510 r6659  
    88# 2) the application fails to use jndi.discoveryDB  
    99# In all the other cases these properties are simply not used 
    10 jdbc.uri = jdbc:postgresql://neptune.badc.rl.ac.uk:5432/discovery_dev 
     10jdbc.uri = jdbc:postgresql://neptune.badc.rl.ac.uk:5432/discovery 
    1111jdbc.username = badc 
    1212jdbc.password = hwk298t 
     
    2626rootElement.DC = dc 
    2727rootElement.MDIP = Metadata 
    28 rootElement.moles = dgMetadata 
    2928rootElement.moles = MD_Metadata 
    3029 
Note: See TracChangeset for help on using the changeset viewer.