Changeset 7393 for RevitalizationWS


Ignore:
Timestamp:
27/08/10 16:34:30 (9 years ago)
Author:
mnagni
Message:

Implemented the IngestSearchLog? service

Location:
RevitalizationWS/ws/DPWS/trunk/src/main/java/ndg/services/revitalization
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • RevitalizationWS/ws/DPWS/trunk/src/main/java/ndg/services/revitalization/ejb/ModelManager.java

    r7389 r7393  
    2424import ndg.services.revitalization.jpa.HiProcess; 
    2525import ndg.services.revitalization.jpa.IngestSearchLogging; 
     26import ndg.services.revitalization.jpa.OaiProvider; 
    2627import ndg.services.revitalization.jpa.ProviderCommon; 
    2728import ndg.services.revitalization.jpa.ProviderEmail; 
     
    4647        private final static String GET_HARVEST_LOG_BY_PROVIDER = "select l, p.providerId from HarvestLog l, HiProcess p  where l.reqId=p.id and p.providerId=:providerID and l.startHarvest >= :start and l.stopHarvest <= :end"; 
    4748        private final static String GET_HARVEST_LOG_ALL_PROVIDER = "select l, p.providerId from HarvestLog l, HiProcess p  where l.reqId=p.id and l.startHarvest >= :start and l.stopHarvest <= :end"; 
     49        private final static String GET_INGEST_LOG_BY_PROVIDER = "select l, p.providerId from IngestSearchLogging l, HiProcess p  where l.reqId=p.id and p.providerId=:providerID and l.startIngest >= :start and l.stopIngest <= :end"; 
     50        private final static String GET_INGEST_LOG_ALL_PROVIDER = "select l, p.providerId from IngestSearchLogging l, HiProcess p  where l.reqId=p.id and l.startIngest >= :start and l.stopIngest <= :end"; 
     51         
    4852 
    4953        @PersistenceContext(unitName = "discoveryDPWS") 
     
    9296         * @return a <code>List</code> of {@link HarvestLog} 
    9397         * */ 
    94         public List<ProviderLogs> getHarvestByProvider(Timestamp start, Timestamp end, int providerId) { 
    95                         Query query = null; 
    96                         if (Double.isNaN(providerId)) { 
    97                                 query = em.createQuery(GET_HARVEST_LOG_ALL_PROVIDER); 
     98        public <T> List<ProviderLogs<T>> getHistoryByProvider(Timestamp start, Timestamp end, int providerId, Class<T> clazz) { 
     99                Query query = null; 
     100                 
     101                String queryAll = null; 
     102                String queryOne = null; 
     103                 
     104                if (clazz.isAssignableFrom(HarvestLog.class) ) { 
     105                        queryAll = GET_HARVEST_LOG_ALL_PROVIDER; 
     106                        queryOne = GET_HARVEST_LOG_BY_PROVIDER; 
     107                } 
     108                 
     109                if (clazz.isAssignableFrom(IngestSearchLogging.class) ) { 
     110                        queryAll = GET_INGEST_LOG_ALL_PROVIDER; 
     111                        queryOne = GET_INGEST_LOG_BY_PROVIDER; 
     112                } 
     113                 
     114                if (Double.isNaN(providerId)) { 
     115                        query = em.createQuery(queryAll); 
     116                } else { 
     117                        query = em.createQuery(queryOne); 
     118                        query.setParameter("providerID", providerId); 
     119                } 
     120 
     121                query.setParameter("start", start); 
     122                query.setParameter("end", end); 
     123 
     124                if (start == null) { 
     125                        Calendar date = Calendar.getInstance(); 
     126                        date.set(Calendar.YEAR, -100); 
     127                        query.setParameter("start", new Timestamp(date.getTimeInMillis())); 
     128                } 
     129 
     130                if (end == null) 
     131                        query.setParameter("end", new Timestamp(Calendar.getInstance().getTimeInMillis())); 
     132 
     133                List<ProviderLogs<T>> ret = new ArrayList<ProviderLogs<T>>(); 
     134                ProviderLogs<T> tempLogs = null; 
     135                for (Iterator iter = query.getResultList().iterator(); iter.hasNext();) { 
     136                        Object[] resultElement = (Object[]) iter.next(); 
     137                        tempLogs = new ProviderLogs<T>((Integer) resultElement[1]); 
     138                        if (tempLogs.getProviderID() == null) 
     139                                continue; 
     140                        int index = ret.indexOf(tempLogs); 
     141                        if (index > -1) { 
     142                                tempLogs = ret.get(index); 
    98143                        } else { 
    99                                 query = em.createQuery(GET_HARVEST_LOG_BY_PROVIDER); 
    100                                 query.setParameter("providerID", providerId); 
    101                         } 
    102  
    103                         query.setParameter("start", start); 
    104                         query.setParameter("end", end); 
    105  
    106                         if (start == null) { 
    107                                 Calendar date = Calendar.getInstance(); 
    108                                 date.set(Calendar.YEAR, -100); 
    109                                 query.setParameter("start", new Timestamp(date.getTimeInMillis())); 
    110                         } 
    111  
    112                         if (end == null) 
    113                                 query.setParameter("end", new Timestamp(Calendar.getInstance().getTimeInMillis())); 
    114  
    115                         List<ProviderLogs> ret = new ArrayList<ProviderLogs>(); 
    116                         ProviderLogs tempLogs = null; 
    117                         for (Iterator iter = query.getResultList().iterator(); iter.hasNext();) { 
    118                                 Object[] resultElement = (Object[]) iter.next(); 
    119                                 tempLogs = new ProviderLogs((Integer) resultElement[1]); 
    120                                 if (tempLogs.getProviderID() == null) 
    121                                         continue; 
    122                                 int index = ret.indexOf(tempLogs); 
    123                                 if (index > -1) { 
    124                                         tempLogs = ret.get(index); 
    125                                 } else { 
    126                                         ret.add(tempLogs); 
    127                                 } 
    128                                 tempLogs.getLogs().add((HarvestLog) resultElement[0]); 
    129                         } 
    130                         return ret; 
     144                                ret.add(tempLogs); 
     145                        } 
     146                        tempLogs.getLogs().add((T) resultElement[0]); 
     147                } 
     148                return ret; 
    131149        } 
    132150 
  • RevitalizationWS/ws/DPWS/trunk/src/main/java/ndg/services/revitalization/ejb/interfaces/ModelManagerLocal.java

    r7360 r7393  
    3333        public List<HarvestLog> getHarvestLog(List<Integer> processIds); 
    3434         
    35         public List<ProviderLogs> getHarvestByProvider(Timestamp start, Timestamp end, int providerId); 
     35        /** 
     36         * Returns the logs relative of a given {@link ProviderCommon} during a specified interval of time 
     37         * @param start the earlier date of a log 
     38         * @param end the latter date of a log  
     39         * @param providerId the provider code  
     40         * @return a list of ProviderLogs 
     41         **/ 
     42        public <T> List<ProviderLogs<T>> getHistoryByProvider(Timestamp start, Timestamp end, int providerId, Class<T> clazz); 
    3643         
    3744        public List<IngestSearchLogging> getIngestLogs(List<Integer> processIds); 
  • RevitalizationWS/ws/DPWS/trunk/src/main/java/ndg/services/revitalization/ejb/interfaces/ModelManagerRemote.java

    r7360 r7393  
    6868         * @param providerId the provider code  
    6969         * @return a list of ProviderLogs 
    70          **/     
    71         public List<ProviderLogs> getHarvestByProvider(Timestamp start, Timestamp end, int providerId); 
     70         **/ 
     71        public <T> List<ProviderLogs<T>> getHistoryByProvider(Timestamp start, Timestamp end, int providerId, Class<T> clazz); 
    7272         
    7373        /** 
  • RevitalizationWS/ws/DPWS/trunk/src/main/java/ndg/services/revitalization/executor/ExecuteGetHarvestHistory.java

    r7312 r7393  
    1616import ndg.services.schemas.revitalization.GetHarvestHistoryResponse; 
    1717import ndg.services.schemas.revitalization.GetHistoryRequest; 
    18 import ndg.services.schemas.revitalization.HarvestInformationType; 
     18import ndg.services.schemas.revitalization.HarvestHistoryType; 
    1919 
    2020public class ExecuteGetHarvestHistory extends ServiceExecutor<GetHistoryRequest, GetHarvestHistoryResponse> { 
     
    3636                                 start = new Timestamp(dateRange.getStart().toGregorianCalendar().getTimeInMillis()); 
    3737                } 
    38                 List<ProviderLogs> logs = EJBBeanFactory.getModelManager().getHarvestByProvider(start, end, request.getProviderID()); 
     38                List<ProviderLogs<HarvestLog>> logs = EJBBeanFactory.getModelManager().getHistoryByProvider(start, end, request.getProviderID(), HarvestLog.class); 
    3939                 
    40                 ProviderLogs provLog = null; 
    41                 HarvestLog item = null; 
    42                 HarvestInformationType informType = null; 
    43                 for (Iterator<ProviderLogs> provIter = logs.iterator() ; provIter.hasNext();) { 
     40                ProviderLogs<HarvestLog> provLog = null; 
     41                HarvestHistoryType historyType = null; 
     42                for (Iterator<ProviderLogs<HarvestLog>> provIter = logs.iterator() ; provIter.hasNext();) { 
    4443                        provLog = provIter.next(); 
    4544                         
    4645                        for (Iterator<HarvestLog> harvLogs = provLog.getLogs().iterator(); harvLogs.hasNext();) { 
    47                                 item = harvLogs.next();  
    48                                 informType = getOf().createHarvestInformationType(); 
    49                                  
    50                                 GregorianCalendar cal = new GregorianCalendar(); 
    51                                 try { 
    52                                         cal.setTime(item.getStartHarvest()); 
    53                                         informType.setHarvestStartTime(DatatypeFactory.newInstance().newXMLGregorianCalendar(cal)); 
    54                                         cal.setTime(item.getStopHarvest()); 
    55                                         informType.setHarvestStopTime(DatatypeFactory.newInstance().newXMLGregorianCalendar(cal)); 
    56                                 } catch (DatatypeConfigurationException e) { 
    57                                         // TODO Auto-generated catch block 
    58                                         e.printStackTrace(); 
    59                                 } 
    60                                 informType.setRequestId(item.getReqId()); 
    61                                 informType.setTotalRecords(item.getTotRecs()); 
    62                                  
    63                                 informType.setProviderID(provLog.getProviderID()); 
    64                                 getResponse().getHarvestingEvent().add(informType);                              
     46                                extractDetails(historyType, harvLogs.next(), provLog);                   
    6547                        } 
    6648                }                                
    6749        } 
    6850 
     51        private void extractDetails(HarvestHistoryType historyType, HarvestLog item, ProviderLogs<HarvestLog> provLog) { 
     52                historyType = getOf().createHarvestHistoryType(); 
     53                 
     54                GregorianCalendar cal = new GregorianCalendar(); 
     55                try { 
     56                        cal.setTime(item.getStartHarvest()); 
     57                        historyType.setHarvestStartTime(DatatypeFactory.newInstance().newXMLGregorianCalendar(cal)); 
     58                        cal.setTime(item.getStopHarvest()); 
     59                        historyType.setHarvestStopTime(DatatypeFactory.newInstance().newXMLGregorianCalendar(cal)); 
     60                } catch (DatatypeConfigurationException e) { 
     61                        // TODO Auto-generated catch block 
     62                        e.printStackTrace(); 
     63                } 
     64                historyType.setRequestId(item.getReqId()); 
     65                historyType.setTotalRecords(item.getTotRecs()); 
     66                 
     67                historyType.setProviderID(provLog.getProviderID()); 
     68                getResponse().getHarvestingEvent().add(historyType);     
     69        }        
    6970} 
  • RevitalizationWS/ws/DPWS/trunk/src/main/java/ndg/services/revitalization/executor/ExecuteGetIngestHistory.java

    r7312 r7393  
    11package ndg.services.revitalization.executor; 
    22 
     3import java.sql.Timestamp; 
     4import java.util.Calendar; 
     5import java.util.GregorianCalendar; 
     6import java.util.Iterator; 
     7import java.util.List; 
     8 
     9import javax.xml.datatype.DatatypeConfigurationException; 
     10import javax.xml.datatype.DatatypeFactory; 
     11 
    312import ndg.common.exception.NdgExecutionException; 
     13import ndg.services.revitalization.EJBBeanFactory; 
     14import ndg.services.revitalization.jpa.IngestLoggingProblemFile; 
     15import ndg.services.revitalization.jpa.IngestSearchLogging; 
     16import ndg.services.schemas.revitalization.DataRangeType; 
    417import ndg.services.schemas.revitalization.GetHistoryRequest; 
    518import ndg.services.schemas.revitalization.GetIngestHistoryResponse; 
     19import ndg.services.schemas.revitalization.IngestHistoryType; 
     20import ndg.services.schemas.revitalization.IngestHistoryType.ProblemFileReport; 
    621 
    722public class ExecuteGetIngestHistory extends ServiceExecutor<GetHistoryRequest, GetIngestHistoryResponse> { 
     
    1429        @Override 
    1530        protected void execute(GetHistoryRequest request) throws NdgExecutionException { 
    16                 // TODO Auto-generated method stub 
     31                DataRangeType dateRange = request.getDateRange(); 
     32                Timestamp end = new Timestamp(Calendar.getInstance().getTimeInMillis()); 
     33                Timestamp start = null; 
     34                if (dateRange != null) { 
     35                        if (dateRange.getEnd() != null) 
     36                                 end = new Timestamp(dateRange.getEnd().toGregorianCalendar().getTimeInMillis()); 
     37                        if (dateRange.getStart() != null) 
     38                                 start = new Timestamp(dateRange.getStart().toGregorianCalendar().getTimeInMillis()); 
     39                } 
     40                List<ProviderLogs<IngestSearchLogging>> logs = EJBBeanFactory.getModelManager().getHistoryByProvider(start, end, request.getProviderID(), IngestSearchLogging.class); 
    1741                 
     42                ProviderLogs<IngestSearchLogging> provLog = null; 
     43                IngestHistoryType historyType = null; 
     44                for (Iterator<ProviderLogs<IngestSearchLogging>> provIter = logs.iterator() ; provIter.hasNext();) { 
     45                        provLog = provIter.next();                       
     46                        for (Iterator<IngestSearchLogging> harvLogs = provLog.getLogs().iterator(); harvLogs.hasNext();) { 
     47                                extractDetails(historyType, harvLogs.next(), provLog);                           
     48                        } 
     49                } 
    1850        } 
    19  
     51         
     52        private void extractDetails(IngestHistoryType historyType, IngestSearchLogging item, ProviderLogs<IngestSearchLogging> provLog) { 
     53                historyType = getOf().createIngestHistoryType(); 
     54                 
     55                GregorianCalendar cal = new GregorianCalendar(); 
     56                try { 
     57                        cal.setTime(item.getStartIngest()); 
     58                        historyType.setIngestStartTime(DatatypeFactory.newInstance().newXMLGregorianCalendar(cal)); 
     59                        cal.setTime(item.getStopIngest()); 
     60                        historyType.setIngestStopTime(DatatypeFactory.newInstance().newXMLGregorianCalendar(cal)); 
     61                } catch (DatatypeConfigurationException e) { 
     62                        // TODO Auto-generated catch block 
     63                        e.printStackTrace(); 
     64                } 
     65                historyType.setRequestId(item.getReqId()); 
     66                historyType.setTotalNumberFilesProcessed(item.getTotalFilesProcessed()); 
     67                historyType.setRecordsCreated(item.getRecordsCreated()); 
     68                historyType.setRecordsDeleted(item.getRecordsDeleted()); 
     69                historyType.setRecordsUpdated(item.getRecordsUpdated());         
     70                historyType.setRecordsProcessedSuccessfully(item.getTotalFilesProcessedSuccessfully()); 
     71                historyType.setRecordsProcessedUnsuccessfully(item.getTotalFilesProcessedUnsuccessfully()); 
     72                historyType.setProviderID(provLog.getProviderID()); 
     73                 
     74                ProblemFileReport pf = null; 
     75                for(IngestLoggingProblemFile report : item.getIngestLoggingProblemFile()){ 
     76                        pf = new ProblemFileReport(); 
     77                        historyType.getProblemFileReport().add(pf); 
     78                        pf.setMessage(report.getProblemFileMessage()); 
     79                        pf.setProblemFileName(report.getProblemFileName()); 
     80                } 
     81                 
     82                getResponse().getIngestEvent().add(historyType);         
     83        } 
    2084} 
  • RevitalizationWS/ws/DPWS/trunk/src/main/java/ndg/services/revitalization/executor/ProviderLogs.java

    r7316 r7393  
    55import java.util.List; 
    66 
    7 import ndg.services.revitalization.jpa.HarvestLog; 
    8  
    9 public class ProviderLogs implements Serializable { 
     7public class ProviderLogs<T> implements Serializable { 
    108        /** 
    119         *  
    1210         */ 
    1311        private static final long serialVersionUID = -7684866617261132458L; 
    14         private final List<HarvestLog> logs = new ArrayList<HarvestLog>(); 
     12        private final List<T> logs = new ArrayList<T>(); 
    1513        private final Integer providerID; 
    1614         
     
    2018        } 
    2119 
    22         public List<HarvestLog> getLogs() { 
     20        public List<T> getLogs() { 
    2321                return logs; 
    2422        } 
  • RevitalizationWS/ws/DPWS/trunk/src/main/java/ndg/services/revitalization/jpa/IngestSearchLogging.java

    r7389 r7393  
    22 
    33import java.io.Serializable; 
    4 import javax.persistence.*; 
    54import java.sql.Timestamp; 
     5import java.util.List; 
     6 
     7import javax.persistence.CascadeType; 
     8import javax.persistence.Column; 
     9import javax.persistence.Entity; 
     10import javax.persistence.FetchType; 
     11import javax.persistence.Id; 
     12import javax.persistence.OneToMany; 
     13import javax.persistence.Table; 
    614 
    715 
     
    1523        private static final long serialVersionUID = 1L; 
    1624        private Integer localIngestId; 
    17         private Integer id; 
    18         private Timestamp ingestDate; 
     25        private Integer reqId; 
    1926        private Integer numberProblemFiles; 
    2027        private Integer recordsCreated; 
     
    2431        private Integer totalFilesProcessedSuccessfully; 
    2532        private Integer totalFilesProcessedUnsuccessfully; 
    26         private IngestLoggingProblemFile ingestLoggingProblemFile; 
     33        private Timestamp startIngest; 
     34        private Timestamp stopIngest; 
     35        private List<IngestLoggingProblemFile> ingestLoggingProblemFile; 
    2736 
    2837    public IngestSearchLogging() { 
     
    4049        } 
    4150 
    42  
    43         public Integer getId() { 
    44                 return this.id; 
     51        @Column(name="id") 
     52        public Integer getReqId() { 
     53                return this.reqId; 
    4554        } 
    4655 
    47         public void setId(Integer id) { 
    48                 this.id = id; 
     56        public void setReqId(Integer reqId) { 
     57                this.reqId = reqId; 
     58        } 
     59 
     60        @Column(name="ingest_start_time") 
     61        public Timestamp getStartIngest() { 
     62                return this.startIngest; 
     63        } 
     64 
     65        public void setStartIngest(Timestamp startIngest) { 
     66                this.startIngest = startIngest; 
    4967        } 
    5068 
    5169 
    52         @Column(name="ingest_date") 
    53         public Timestamp getIngestDate() { 
    54                 return this.ingestDate; 
     70        @Column(name="ingest_end_time") 
     71        public Timestamp getStopIngest() { 
     72                return this.stopIngest; 
    5573        } 
    5674 
    57         public void setIngestDate(Timestamp ingestDate) { 
    58                 this.ingestDate = ingestDate; 
    59         } 
    60  
     75        public void setStopIngest(Timestamp stopIngest) { 
     76                this.stopIngest = stopIngest; 
     77        }        
    6178 
    6279        @Column(name="number_problem_files") 
     
    129146        } 
    130147 
    131  
    132         //uni-directional one-to-one association to IngestLoggingProblemFile 
    133         @OneToOne 
    134         @JoinColumn(name="local_ingest_id") 
    135         public IngestLoggingProblemFile getIngestLoggingProblemFile() { 
     148        @OneToMany(mappedBy="id", cascade={CascadeType.ALL}, fetch=FetchType.EAGER) 
     149        public List<IngestLoggingProblemFile> getIngestLoggingProblemFile() { 
    136150                return this.ingestLoggingProblemFile; 
    137151        } 
    138152 
    139         public void setIngestLoggingProblemFile(IngestLoggingProblemFile ingestLoggingProblemFile) { 
     153        public void setIngestLoggingProblemFile(List<IngestLoggingProblemFile> ingestLoggingProblemFile) { 
    140154                this.ingestLoggingProblemFile = ingestLoggingProblemFile; 
    141155        } 
Note: See TracChangeset for help on using the changeset viewer.