Changeset 6511


Ignore:
Timestamp:
08/02/10 16:40:33 (10 years ago)
Author:
mnagni
Message:

First implementation of the doPresent (almost completely ingested what was the second part action of the doSearch)
Cleaned up some unused classes

Location:
TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg
Files:
1 added
4 deleted
5 edited

Legend:

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

    r6504 r6511  
    33import ndg.common.NdgMessage; 
    44 
     5/** 
     6 * Defines the basic exception class for an SQL operation 
     7 *  
     8 * @author Maurizio Nagni <maurizio.nagni@stcf.ac.uk> 
     9 * */ 
    510public class NdgSQLException extends NdgException { 
    611 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/DiscoveryServiceMEDINSkeleton.java

    r6504 r6511  
    33import java.beans.PropertyDescriptor; 
    44import java.lang.reflect.InvocationTargetException; 
     5import java.util.ArrayList; 
    56import java.util.List; 
    67 
     
    1213import ndg.services.discovery.medin.DiscoveryDictionary; 
    1314import ndg.services.discovery.medin.DiscoveryDictionary.OrderByField; 
     15import ndg.services.discovery.medin.DiscoveryDictionary.RecordDetail; 
     16import ndg.services.discovery.model.PresentAgent; 
    1417import ndg.services.discovery.model.SearchAgent; 
    1518import ndg.services.jpa.OriginalDocument; 
     
    1821import org.apache.xmlbeans.XmlString; 
    1922 
     23import discoveryserviceapi.DoPresentDocument; 
     24import discoveryserviceapi.DoPresentReturnDocument; 
    2025import discoveryserviceapi.DoSearchDocument; 
    2126import discoveryserviceapi.DoSearchReturnDocument; 
     27import discoveryserviceapi.GetListDocument; 
     28import discoveryserviceapi.GetListReturnDocument; 
     29import discoveryserviceapi.GetListReturnType; 
    2230import discoveryserviceapi.OrderByType; 
    2331import discoveryserviceapi.OrderingMetricType; 
     32import discoveryserviceapi.PresentReturnType; 
    2433import discoveryserviceapi.ReturnBriefType; 
    2534import discoveryserviceapi.ReturnFullType; 
     
    2736import discoveryserviceapi.SearchReturnType; 
    2837import discoveryserviceapi.SearchType; 
    29 import discoveryserviceapi.SearchReturnType.Documents; 
    3038 
    3139/** 
    3240 * DiscoveryServiceMEDINSkeleton java skeleton for the axisService 
     41 *  
     42 * @author Maurizio Nagni <maurizio.nagni@stcf.ac.uk> 
    3343 */ 
    3444public class DiscoveryServiceMEDINSkeleton implements DiscoveryServiceMEDINSkeletonInterface { 
     
    193203                try { 
    194204                        List<OriginalDocument> result = agent.doSearch(); 
    195                         processResult(result, responseContent.addNewDocuments(), doSearch.getDoSearch()); 
    196  
     205                        SearchType st = doSearch.getDoSearch(); 
     206                        DiscoveryDictionary.RecordDetail type = DiscoveryDictionary.getRecordDetails(st.getRecordDetail()); 
     207                        processResult(result, responseContent.addNewDocuments(), type, st.getOrderByArray()); 
    197208                        status = (result != null && result.size() > 0 ? true : false); 
    198209                } catch (NdgSQLException e) { 
     
    220231                 * logger.info("Tracking DB insert stmnt: " + sqlInsertStmnt); 
    221232                 *  
    222                  *  
     233                 * PresentType 
    223234                 * //execute statement to search logging database try { if 
    224235                 * (DBProperties.updateSearchParamLoggingDb(sqlInsertStmnt)) { 
     
    266277         */ 
    267278 
    268         public discoveryserviceapi.DoPresentReturnDocument doPresent(discoveryserviceapi.DoPresentDocument doPresent) { 
    269                 // TODO : fill this with the necessary business logic 
    270                 throw new java.lang.UnsupportedOperationException("Please implement " + this.getClass().getName() 
    271                                 + "#doPresent"); 
     279        public DoPresentReturnDocument doPresent(DoPresentDocument doPresent) { 
     280                DoPresentReturnDocument response = DoPresentReturnDocument.Factory.newInstance(); 
     281                PresentReturnType responseContent = response.addNewDoPresentReturn(); 
     282                 
     283                boolean status = false; 
     284                String statusMessage = "Normal"; 
     285                PresentAgent agent = new PresentAgent(); 
     286                List<String> documentsId = new ArrayList<String>(); 
     287                try { 
     288                        String[] docIds = doPresent.getDoPresent().getDocuments().getDocumentIdArray(); 
     289                        if (docIds != null) { 
     290                                for (String docId : doPresent.getDoPresent().getDocuments().getDocumentIdArray()) { 
     291                                        documentsId.add(docId); 
     292                                }                                
     293                        } 
     294 
     295                        RecordDetail detail = RecordDetail.DocumentFull; 
     296                        List<OriginalDocument> result = agent.doPresent(null, documentsId, detail); 
     297                        processResult(result, responseContent.addNewDocuments(), detail, null); 
     298                        status = (result != null && result.size() >      0 ? true : false); 
     299                } catch (NdgSQLException e) { 
     300                        statusMessage = e.getMessage(); 
     301                } catch (ResourceNotAvailable e) { 
     302                        statusMessage = e.getMessage(); 
     303                } finally { 
     304                        responseContent.setStatus(status); 
     305                        responseContent.setStatusMessage(statusMessage); 
     306                } 
     307                 
     308                return response; 
    272309        } 
    273310 
     
    280317         * @throws DiscoveryWSException 
    281318         */ 
    282         public discoveryserviceapi.GetListReturnDocument getList(discoveryserviceapi.GetListDocument request) { 
     319        public GetListReturnDocument getList(GetListDocument request) { 
    283320                logger.info("getList() invoked"); 
    284                 discoveryserviceapi.GetListReturnDocument response = discoveryserviceapi.GetListReturnDocument.Factory 
     321                GetListReturnDocument response = GetListReturnDocument.Factory 
    285322                                .newInstance(); 
    286                 discoveryserviceapi.GetListReturnType responseContent = response.addNewGetListReturn(); 
    287                 discoveryserviceapi.GetListReturnType.List list = responseContent.addNewList(); 
     323                GetListReturnType responseContent = response.addNewGetListReturn(); 
     324                GetListReturnType.List list = responseContent.addNewList(); 
    288325 
    289326                // parse the request message 
    290327                discoveryserviceapi.GetListType requestContent = request.getGetList(); 
     328                 
    291329                String listName = requestContent.getListName().trim(); 
    292330                list.setName(listName); 
     
    427465         */ 
    428466 
    429         private void processResult(List<OriginalDocument> results, Documents documents, SearchType criteria) { 
     467        private void processResult(List<OriginalDocument> results, PresentReturnType.Documents documents, RecordDetail type, OrderByType[] orderBy) { 
     468                if (results != null && results.size() == 0) 
     469                        return; 
     470                for (OriginalDocument result : results) { 
     471                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) { 
     472                                ReturnFullType fullType = documents.addNewDocumentFull();                                
     473                                fullType.setDocumentId(result.getOriginalDocumentFilename()); 
     474                                fullType.setTitle(result.getDatasetName()); 
     475                                fullType.setDocument(result.getOriginalDocument()); 
     476                                fullType.setAbstract(result.getDatasetAbstract()); 
     477                        } 
     478                } 
     479        }        
     480         
     481        private void processResult(List<OriginalDocument> results, SearchReturnType.Documents documents, RecordDetail type, OrderByType[] orderBy) { 
    430482                if (results != null && results.size() == 0) 
    431483                        return; 
    432484                 
    433                 DiscoveryDictionary.RecordDetail type = DiscoveryDictionary.getRecordDetails(criteria.getRecordDetail()); 
    434  
    435485                /** all the IFs should be revisited */ 
    436486                for (OriginalDocument result : results) { 
     
    466516                                documentType = briefType; 
    467517                        } 
    468                         fillOrderedFieldArray(documentType, criteria.getOrderByArray(), result); 
     518                        if (orderBy != null)  
     519                                fillOrderedFieldArray(documentType, orderBy, result); 
    469520                } 
    470521        } 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/medin/DiscoveryBasic.java

    r6510 r6511  
    1313import ndg.common.exception.NdgException; 
    1414import ndg.common.exception.ResourceNotAvailable; 
    15 import ndg.services.discovery.exception.DiscoveryDBException; 
    1615 
    1716import org.apache.log4j.Logger; 
     
    3635        private final static DiscoveryBasic instance = new DiscoveryBasic(); 
    3736 
    38         private static Logger logger = Logger.getLogger(DiscoveryDBException.class.getName()); 
     37        private static Logger logger = Logger.getLogger(DiscoveryBasic.class.getName()); 
    3938 
    4039        // Hides the constructor 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/medin/DiscoveryDictionary.java

    r6510 r6511  
    77 
    88import ndg.services.jpa.OriginalDocument; 
     9import discoveryserviceapi.PresentReturnType; 
     10import discoveryserviceapi.ReturnFullType; 
     11import discoveryserviceapi.ReturnSummaryType; 
     12import discoveryserviceapi.SearchReturnType; 
    913 
    1014 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/SearchAgent.java

    r6510 r6511  
    11package ndg.services.discovery.model; 
    22 
    3 import java.beans.PropertyDescriptor; 
    4 import java.lang.reflect.InvocationTargetException; 
    53import java.sql.Connection; 
    64import java.sql.ResultSet; 
     
    86import java.sql.Statement; 
    97import java.util.ArrayList; 
    10 import java.util.Iterator; 
    118import java.util.List; 
    129 
     
    1714import ndg.services.discovery.medin.DiscoveryBasic; 
    1815import ndg.services.discovery.medin.DiscoveryDictionary; 
    19 import ndg.services.discovery.medin.DiscoveryDictionary.OrderByField; 
    2016import ndg.services.discovery.medin.DiscoveryDictionary.TemporalOperator; 
    2117import ndg.services.jpa.OriginalDocument; 
     
    9692         *                available 
    9793         **/ 
    98         private List<OriginalDocument> searchDocuments(Connection conn, SearchCriteria criteria) throws NdgSQLException { 
     94        private List<OriginalDocument> searchDocuments(Connection conn, SearchCriteria criteria)  
     95                        throws NdgSQLException, ResourceNotAvailable { 
    9996                List<OriginalDocument> res = new ArrayList<OriginalDocument>(); 
    10097                List<String> toFilter = executeSearch(conn, assembleSearch(criteria)); 
     
    114111 
    115112                toFilter = toFilter.subList((int) start, (int) howMany); 
    116                 res = retrieveDocuments(conn, toFilter); 
    117  
     113                PresentAgent present = new PresentAgent(){ 
     114                        void orderByHook(StringBuffer whereSQL, StringBuffer sqlCmd) { 
     115                                StringBuffer orderSQL = getOrderBy(sqlCmd); 
     116                                /* -- Append the ORDER BY clause to the WHERE command -- */ 
     117                                if (orderSQL.length() > 0) { 
     118                                        whereSQL.append(" ORDER BY "); 
     119                                        whereSQL.append(orderSQL); 
     120                                }        
     121                        } 
     122                }; 
     123                DiscoveryDictionary.RecordDetail type = DiscoveryDictionary.getRecordDetails(searchType.getRecordDetail()); 
     124                res = present.doPresent(conn, toFilter, type); 
    118125                return res; 
    119126        } 
     
    154161                } 
    155162                return ret; 
    156         } 
    157  
    158         /** 
    159          * Executes the search and returns a SearchSummary object 
    160          *  
    161          * @return SearchSummary object containing result of search 
    162          * @throws ResourceNotAvailable 
    163          *             if the <code>Connection</code> is not available 
    164          * @throws NdgSQLException 
    165          *             If a database access exception occurs 
    166          */ 
    167         private List<OriginalDocument> retrieveDocuments(Connection conn, List<String> documentsId) throws NdgSQLException { 
    168                 List<OriginalDocument> ret = new ArrayList<OriginalDocument>(); 
    169                 if (documentsId == null || documentsId.size() == 0) 
    170                         return ret; 
    171                 Statement stat = null; 
    172                 ResultSet rs = null; 
    173                 String sqlQuery = assembleRetrieve(documentsId); 
    174                 NdgMessage msg = null; 
    175                 if (logger.isInfoEnabled()) { 
    176                         msg = new NdgMessage("sql.command", new Object[] { sqlQuery.toString() }); 
    177                         logger.info(getMsgFormatter().getFormattedText(msg)); 
    178                 } 
    179                 try { 
    180                         stat = conn.createStatement(); 
    181                         rs = stat.executeQuery(sqlQuery); 
    182                 } catch (SQLException e) { 
    183                         closeStatement(stat, rs); 
    184                         msg = new NdgMessage("sql.execution.error", new Object[] { sqlQuery }); 
    185                         throw new NdgSQLException(msg); 
    186                 } 
    187  
    188                 OriginalDocument item; 
    189  
    190                 if (rs != null) { 
    191                         while (true) { 
    192                                 try { 
    193                                         if (!rs.next()) 
    194                                                 break; 
    195                                 } catch (SQLException e) { 
    196                                         logger.error(rs.toString(), e); 
    197                                         break; 
    198                                 } 
    199                                 try { 
    200                                         item = fillMEDINSearchResult(rs); 
    201                                         ret.add(item); 
    202                                 } catch (SQLException e) { 
    203                                         logger.error(rs.toString(), e); 
    204                                 } 
    205                         } 
    206                 } 
    207                 closeStatement(stat, rs); 
    208                 return ret; 
    209         } 
    210  
    211         private String assembleRetrieve(List<String> documentsId) { 
    212  
    213                 DiscoveryDictionary.RecordDetail type = DiscoveryDictionary.getRecordDetails(searchType.getRecordDetail()); 
    214                 StringBuffer sqlCmd = new StringBuffer("SELECT "); 
    215  
    216                 /** all the IFs should be revisited */ 
    217                 if (type.equals(DiscoveryDictionary.RecordDetail.DocumentId)) { 
    218                         sqlCmd.append(" original_document_filename"); 
    219                 } 
    220                 if (type.equals(DiscoveryDictionary.RecordDetail.DocumentBrief)) { 
    221                         sqlCmd.append(" original_document_filename, dataset_name"); 
    222                 } 
    223                 if (type.equals(DiscoveryDictionary.RecordDetail.DocumentSummary)) { 
    224                         sqlCmd.append(" original_document_filename, dataset_name, dataset_abstract"); 
    225                 } 
    226                 if (type.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) { 
    227                         sqlCmd.append(" original_document_filename, dataset_name, dataset_abstract, original_document"); 
    228                 } 
    229  
    230                 /* -----WHERE----- */ 
    231                 StringBuffer whereSQL = new StringBuffer(); 
    232                 whereSQL.append(" FROM original_document WHERE original_document_filename IN ("); 
    233  
    234                 Iterator<String> iter = documentsId.iterator(); 
    235                 while (iter.hasNext()) { 
    236                         whereSQL.append("'"); 
    237                         whereSQL.append(iter.next()); 
    238                         whereSQL.append("'"); 
    239                         if (iter.hasNext()) 
    240                                 whereSQL.append(", "); 
    241                 } 
    242                 whereSQL.append(") "); 
    243  
    244                 /* -----ORDER BY----- */ 
    245                 StringBuffer orderSQL = getOrderBy(sqlCmd); 
    246                 /* -- Append the ORDER BY clause to the WHERE command -- */ 
    247                 if (orderSQL.length() > 0) { 
    248                         whereSQL.append(" ORDER BY "); 
    249                         whereSQL.append(orderSQL); 
    250                 } 
    251                 /* -- Append the FROM-WHERE clause to the SELECT command -- */ 
    252                 sqlCmd.append(whereSQL); 
    253                 return sqlCmd.toString(); 
    254163        } 
    255164 
     
    448357        } 
    449358 
    450         /** 
    451          *  
    452          * @throws SQLException 
    453          *             if one column exists in the resultset but returns an error on 
    454          *             reading its value 
    455          **/ 
    456         private OriginalDocument fillMEDINSearchResult(ResultSet rs) throws SQLException { 
    457                 OriginalDocument od = new OriginalDocument(); 
    458  
    459                 if (columnExist(rs, "original_document_filename")) 
    460                         od.setOriginalDocumentFilename(rs.getString("original_document_filename")); 
    461  
    462                 if (columnExist(rs, "dataset_name")) 
    463                         od.setDatasetName(rs.getString("dataset_name")); 
    464  
    465                 if (columnExist(rs, "original_document")) 
    466                         od.setOriginalDocument(rs.getString("original_document")); 
    467  
    468                 if (columnExist(rs, "dataset_abstract")) 
    469                         od.setDatasetAbstract(rs.getString("dataset_abstract")); 
    470  
    471                 NdgMessage msg = new NdgMessage("invocation.error", new Object[] { "Field.get(result)" });                       
    472                 for (OrderByField order : DiscoveryDictionary.OrderByField.values()) { 
    473                         if (columnExist(rs, order.fieldName())) 
    474                                 try { 
    475                                         PropertyDescriptor field = DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()); 
    476                                         Class<?> type = field.getPropertyType(); 
    477                                         if (String.class.isAssignableFrom(type)) { 
    478                                                 DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()).getWriteMethod().invoke(od, rs.getString(order.fieldName())); 
    479                                         } else if (java.sql.Timestamp.class.isAssignableFrom(type)) { 
    480                                                 DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()).getWriteMethod().invoke(od, rs.getTimestamp((order.fieldName())));                                   
    481                                         } else if (Integer.class.isAssignableFrom(type)) {               
    482                                                 field.getWriteMethod().invoke(od, rs.getString(rs.getInt((order.fieldName()))));                                                                                         
    483                                         } 
    484                                 } catch (IllegalArgumentException e) { 
    485                                         logger.error(msg, e); 
    486                                 } catch (IllegalAccessException e) { 
    487                                         logger.error(msg, e); 
    488                                 } catch (InvocationTargetException e) { 
    489                                         logger.error(msg, e); 
    490                                 } 
    491                 }                
    492                 return od; 
    493         } 
    494  
    495         private boolean columnExist(ResultSet rs, String columnName) { 
    496                 boolean columnExist = false; 
    497                 try { 
    498                         rs.findColumn(columnName); 
    499                         columnExist = true; 
    500                 } catch (SQLException e) { 
    501                 } 
    502                 return columnExist; 
    503         } 
    504  
    505359        private MessageFormatter getMsgFormatter() { 
    506360                return DiscoveryBasic.getInstance().getFormatter(); 
     
    571425                        } 
    572426                } 
    573  
    574427                return orderSQL; 
    575428        } 
Note: See TracChangeset for help on using the changeset viewer.