Changeset 1555


Ignore:
Timestamp:
03/14/14 11:28:32 (5 years ago)
Author:
philsmart
Message:
 
Location:
raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/event/expansion/ResourceCategoryAttributeAssociationDefinition.java

    r1475 r1555  
    2323import org.slf4j.LoggerFactory; 
    2424import org.springframework.dao.DataAccessException; 
     25import org.springframework.dao.IncorrectResultSizeDataAccessException; 
    2526 
    2627import uk.ac.cardiff.model.event.Event; 
     
    3334 * @author philsmart 
    3435 */ 
    35 public class ResourceCategoryAttributeAssociationDefinition extends 
    36         BaseAttributeAssociationDefinition { 
     36public class ResourceCategoryAttributeAssociationDefinition extends BaseAttributeAssociationDefinition { 
    3737 
    38     /** Class logger. */ 
    39     private final Logger log = LoggerFactory 
    40             .getLogger(ResourceCategoryAttributeAssociationDefinition.class); 
     38        /** Class logger. */ 
     39        private final Logger log = LoggerFactory.getLogger(ResourceCategoryAttributeAssociationDefinition.class); 
    4140 
    42     /** The data connector used to acquire the attributes. */ 
    43     private RaptorDataConnection dataConnection; 
     41        /** The data connector used to acquire the attributes. */ 
     42        private RaptorDataConnection dataConnection; 
    4443 
    45     /** 
    46     * @see uk.ac.cardiff.raptor.event.expansion.BaseAttributeAssociationDefinition#initialise() 
    47     */ 
    48     @Override 
    49     public void initialise() { 
    50     } 
     44        /** 
     45        * @see uk.ac.cardiff.raptor.event.expansion.BaseAttributeAssociationDefinition#initialise() 
     46        */ 
     47        @Override 
     48        public void initialise() { 
     49        } 
    5150 
    52     @Override 
    53     public boolean associate(final Event event) { 
     51        @Override 
     52        public boolean associate(final Event event) { 
    5453 
    55         ResourceMetadata resourceMetadata = null; 
    56         Object result = null; 
    57         if (event.getResourceId() != null) { 
    58             result = 
    59                     dataConnection.runQueryUnique( 
    60                             "from ResourceMetadata where resourceId=?", 
    61                             new Object[] {event.getResourceId()}); 
    62         } 
    63         if (result != null && result instanceof ResourceMetadata) { 
    64             resourceMetadata = (ResourceMetadata) result; 
    65             if (resourceMetadata.isExternal()) { 
    66                 event.setResourceIdCategory(2); 
    67             } else if (resourceMetadata.isInternal()) { 
    68                 event.setResourceIdCategory(1); 
    69             } 
    70             return true; 
    71         } else { 
    72             // only set new resource information if has resource id. However, must set default resources category anyway 
    73             if (event.getResourceId() != null) { 
    74                 ResourceMetadata resourceNew = new ResourceMetadata(); 
    75                 resourceNew.setExternal(true); 
    76                 resourceNew.setInternal(false); 
    77                 resourceNew.setResourceId(event.getResourceId()); 
    78                 // set event to default resource category, then save this resourceId. 
    79                 event.setResourceIdCategory(2); 
    80                 try { 
    81                     dataConnection.save(resourceNew); 
    82                 } catch (DataAccessException e) { 
    83                     log.error("Could not save new resource metadata {}", e.getMessage()); 
    84                     return false; 
    85                 } 
    86                 return true; 
    87             } else { 
    88                 event.setResourceIdCategory(2); 
    89                 return false; 
    90             } 
    91         } 
     54                ResourceMetadata resourceMetadata = null; 
     55                Object result = null; 
     56                if (event.getResourceId() != null) { 
     57                        try { 
     58                                result = dataConnection.runQueryUnique("from ResourceMetadata where resourceId=?", 
     59                                                new Object[] { event.getResourceId() }); 
     60                        } catch (IncorrectResultSizeDataAccessException e) { 
     61                                log.error("Query for {} returned the wrong number of results: ", event.getResourceId(), e.getMessage()); 
     62                        } 
     63                } 
    9264 
    93     } 
     65                if (result != null && result instanceof ResourceMetadata) { 
     66                        resourceMetadata = (ResourceMetadata) result; 
     67                        if (resourceMetadata.isExternal()) { 
     68                                event.setResourceIdCategory(2); 
     69                        } else if (resourceMetadata.isInternal()) { 
     70                                event.setResourceIdCategory(1); 
     71                        } 
     72                        return true; 
     73                } else { 
     74                        // only set new resource information if has resource id. However, 
     75                        // must set default resources category anyway 
     76                        if (event.getResourceId() != null) { 
     77                                ResourceMetadata resourceNew = new ResourceMetadata(); 
     78                                resourceNew.setExternal(true); 
     79                                resourceNew.setInternal(false); 
     80                                resourceNew.setResourceId(event.getResourceId()); 
     81                                // set event to default resource category, then save this 
     82                                // resourceId. 
     83                                event.setResourceIdCategory(2); 
     84                                try { 
     85                                        dataConnection.save(resourceNew); 
     86                                } catch (DataAccessException e) { 
     87                                        log.error("Could not save new resource metadata {}", e.getMessage()); 
     88                                        return false; 
     89                                } 
     90                                return true; 
     91                        } else { 
     92                                event.setResourceIdCategory(2); 
     93                                return false; 
     94                        } 
     95                } 
    9496 
    95     /** 
    96      * Sets the class to add. 
    97      *  
    98      * @param classToAdd the classToAdd to set 
    99      */ 
    100     @Override 
    101     public void setClassToAdd(Class<?> classToAdd) { 
    102         this.classToAdd = classToAdd; 
    103     } 
     97        } 
    10498 
    105     /** 
    106      * Gets the class to add. 
    107      *  
    108      * @return the classToAdd 
    109      */ 
    110     @Override 
    111     public Class<?> getClassToAdd() { 
    112         return classToAdd; 
    113     } 
     99        /** 
     100         * Sets the class to add. 
     101         *  
     102         * @param classToAdd 
     103         *            the classToAdd to set 
     104         */ 
     105        @Override 
     106        public void setClassToAdd(Class<?> classToAdd) { 
     107                this.classToAdd = classToAdd; 
     108        } 
    114109 
    115     /** 
    116      * Sets the associate with class. 
    117     *  
    118      * @param associateWithClass the associateWithClass to set 
    119     */ 
    120     @Override 
    121     public void setAssociateWithClass(String associateWithClass) { 
    122         this.associateWithClass = associateWithClass; 
    123     } 
     110        /** 
     111         * Gets the class to add. 
     112        *  
     113         * @return the classToAdd 
     114        */ 
     115        @Override 
     116        public Class<?> getClassToAdd() { 
     117                return classToAdd; 
     118        } 
    124119 
    125     /** 
    126      * Gets the associate with class. 
    127      *  
    128      * @return the associateWithClass 
    129      */ 
    130     @Override 
    131     public String getAssociateWithClass() { 
    132         return associateWithClass; 
    133     } 
     120        /** 
     121         * Sets the associate with class. 
     122         *  
     123         * @param associateWithClass 
     124         *            the associateWithClass to set 
     125         */ 
     126        @Override 
     127        public void setAssociateWithClass(String associateWithClass) { 
     128                this.associateWithClass = associateWithClass; 
     129        } 
    134130 
    135     /** 
    136      * Sets the data connection. 
    137      *  
    138      * @param dataConnection the dataConnection to set 
    139      */ 
    140     public void setDataConnection(RaptorDataConnection dataConnection) { 
    141         this.dataConnection = dataConnection; 
    142     } 
     131        /** 
     132         * Gets the associate with class. 
     133         *  
     134         * @return the associateWithClass 
     135         */ 
     136        @Override 
     137        public String getAssociateWithClass() { 
     138                return associateWithClass; 
     139        } 
    143140 
    144     /** 
    145      * Gets the data connection. 
    146      *  
    147      * @return the dataConnection 
    148      */ 
    149     public RaptorDataConnection getDataConnection() { 
    150         return dataConnection; 
    151     } 
     141        /** 
     142         * Sets the data connection. 
     143         *  
     144         * @param dataConnection 
     145         *            the dataConnection to set 
     146         */ 
     147        public void setDataConnection(RaptorDataConnection dataConnection) { 
     148                this.dataConnection = dataConnection; 
     149        } 
     150 
     151        /** 
     152         * Gets the data connection. 
     153         *  
     154         * @return the dataConnection 
     155         */ 
     156        public RaptorDataConnection getDataConnection() { 
     157                return dataConnection; 
     158        } 
    152159 
    153160} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/dao/DefaultDataConnection.java

    r1515 r1555  
    2929import org.slf4j.LoggerFactory; 
    3030import org.springframework.dao.DataAccessException; 
     31import org.springframework.dao.IncorrectResultSizeDataAccessException; 
    3132import org.springframework.dao.support.DataAccessUtils; 
    3233import org.springframework.orm.hibernate3.HibernateCallback; 
     
    3940public class DefaultDataConnection implements RaptorDataConnection { 
    4041 
    41     /** hibernate template to persist classes */ 
    42     private HibernateTemplate hibernateTemplate; 
     42        /** hibernate template to persist classes */ 
     43        private HibernateTemplate hibernateTemplate; 
    4344 
    44     @SuppressWarnings("unused") 
    45     private SessionFactory sessionFactory; 
     45        @SuppressWarnings("unused") 
     46        private SessionFactory sessionFactory; 
    4647 
    47     /** class logger */ 
    48     private static Logger log = LoggerFactory.getLogger(DefaultDataConnection.class); 
     48        /** class logger */ 
     49        private static Logger log = LoggerFactory.getLogger(DefaultDataConnection.class); 
    4950 
    50     @Override 
    51     public void save(Object object) throws DataAccessException { 
    52         hibernateTemplate.saveOrUpdate(object); 
    53     } 
     51        @Override 
     52        public void save(Object object) throws DataAccessException { 
     53                hibernateTemplate.saveOrUpdate(object); 
     54        } 
    5455 
    55     @Override 
    56     public void saveAll(@SuppressWarnings("rawtypes") Collection collection) throws DataAccessException { 
    57         hibernateTemplate.saveOrUpdateAll(collection); 
    58     } 
     56        @Override 
     57        public void saveAll(@SuppressWarnings("rawtypes") Collection collection) throws DataAccessException { 
     58                hibernateTemplate.saveOrUpdateAll(collection); 
     59        } 
    5960 
    60     @Override 
    61     @SuppressWarnings("rawtypes") 
    62     public List runQuery(String query, Object[] parameters) throws DataAccessException { 
    63         return hibernateTemplate.find(query, parameters); 
    64     } 
     61        @Override 
     62        @SuppressWarnings("rawtypes") 
     63        public List runQuery(String query, Object[] parameters) throws DataAccessException { 
     64                return hibernateTemplate.find(query, parameters); 
     65        } 
    6566 
    66     @Override 
    67     public void runUpdate(String query, Object[] parameters) throws DataAccessException { 
    68         hibernateTemplate.bulkUpdate(query, parameters); 
    69     } 
     67        @Override 
     68        public void runUpdate(String query, Object[] parameters) throws DataAccessException { 
     69                hibernateTemplate.bulkUpdate(query, parameters); 
     70        } 
    7071 
    71     @Override 
    72     @SuppressWarnings("rawtypes") 
    73     public List runQuery(String query, Object[] parameters, int maxResultSize) throws DataAccessException { 
    74         hibernateTemplate.setMaxResults(maxResultSize); 
    75         List result = hibernateTemplate.find(query, parameters); 
    76         hibernateTemplate.setMaxResults(0); 
    77         return result; 
    78     } 
     72        @Override 
     73        @SuppressWarnings("rawtypes") 
     74        public List runQuery(String query, Object[] parameters, int maxResultSize) throws DataAccessException { 
     75                hibernateTemplate.setMaxResults(maxResultSize); 
     76                List result = hibernateTemplate.find(query, parameters); 
     77                hibernateTemplate.setMaxResults(0); 
     78                return result; 
     79        } 
    7980 
    80     /** 
    81     * Not used method. Specific to this implementation for testing. 
    82     *  
    83     * @param query 
    84     * @param pageSize 
    85     * @param pageNumber 
    86     * @return 
    87     * @throws DataAccessException 
    88     */ 
    89     @SuppressWarnings("rawtypes") 
    90     public List runQueryPaged(final String query, final int pageSize, final int pageNumber) throws DataAccessException { 
    91         HibernateTemplate template = getHibernateTemplate(); 
    92         return template.executeFind(new HibernateCallback() { 
    93             @Override 
    94             public Object doInHibernate(Session session) throws HibernateException, SQLException { 
    95                 Query queryToRun = session.createQuery(query); 
    96                 queryToRun.setMaxResults(pageSize); 
    97                 queryToRun.setFirstResult(pageSize * pageNumber); 
    98                 return queryToRun.list(); 
    99             } 
    100         }); 
    101     } 
     81        /** 
     82        * Not used method. Specific to this implementation for testing. 
     83        *  
     84        * @param query 
     85        * @param pageSize 
     86        * @param pageNumber 
     87        * @return 
     88        * @throws DataAccessException 
     89        */ 
     90        @SuppressWarnings("rawtypes") 
     91        public List runQueryPaged(final String query, final int pageSize, final int pageNumber) throws DataAccessException { 
     92                HibernateTemplate template = getHibernateTemplate(); 
     93                return template.executeFind(new HibernateCallback() { 
     94                        @Override 
     95                        public Object doInHibernate(Session session) throws HibernateException, SQLException { 
     96                                Query queryToRun = session.createQuery(query); 
     97                                queryToRun.setMaxResults(pageSize); 
     98                                queryToRun.setFirstResult(pageSize * pageNumber); 
     99                                return queryToRun.list(); 
     100                        } 
     101                }); 
     102        } 
    102103 
    103     @SuppressWarnings("unchecked") 
    104     @Override 
    105     public Object runQueryForceUnique(final String query, final Object[] parameters) { 
    106         if (parameters != null) { 
    107             log.trace("Query to database, {}, with params [{}]", query, Arrays.asList(parameters)); 
    108         } else { 
    109             log.trace("Query to database, {}]", query); 
    110         } 
    111         HibernateTemplate template = getHibernateTemplate(); 
    112         return template.execute(new HibernateCallback() { 
    113             @Override 
    114             public Object doInHibernate(Session session) throws HibernateException, SQLException { 
    115                 Query queryToRun = session.createQuery(query); 
    116                 queryToRun.setMaxResults(1); 
    117                 return queryToRun.uniqueResult(); 
    118             } 
    119         }); 
    120     } 
     104        @SuppressWarnings("unchecked") 
     105        @Override 
     106        public Object runQueryForceUnique(final String query, final Object[] parameters) { 
     107                if (parameters != null) { 
     108                        log.trace("Query to database, {}, with params [{}]", query, Arrays.asList(parameters)); 
     109                } else { 
     110                        log.trace("Query to database, {}]", query); 
     111                } 
     112                HibernateTemplate template = getHibernateTemplate(); 
     113                return template.execute(new HibernateCallback() { 
     114                        @Override 
     115                        public Object doInHibernate(Session session) throws HibernateException, SQLException { 
     116                                Query queryToRun = session.createQuery(query); 
     117                                queryToRun.setMaxResults(1); 
     118                                return queryToRun.uniqueResult(); 
     119                        } 
     120                }); 
     121        } 
    121122 
    122     @SuppressWarnings("unchecked") 
    123     @Override 
    124     public Object runQueryUnique(String query, Object[] parameters) throws DataAccessException { 
    125         if (parameters != null) { 
    126             log.trace("Query to database, {}, with params [{}]", query, Arrays.asList(parameters)); 
    127         } else { 
    128             log.trace("Query to database, {}]", query); 
    129         } 
    130         Object object = DataAccessUtils.uniqueResult(getHibernateTemplate().find(query, parameters)); 
    131         return object; 
    132     } 
     123        @SuppressWarnings("unchecked") 
     124        @Override 
     125        public Object runQueryUnique(String query, Object[] parameters) throws DataAccessException { 
     126                if (parameters != null) { 
     127                        log.trace("Query to database, {}, with params [{}]", query, Arrays.asList(parameters)); 
     128                } else { 
     129                        log.trace("Query to database, {}]", query); 
     130                } 
    133131 
    134     public void setHibernateTemplate(HibernateTemplate hibernateTemplate) { 
    135         this.hibernateTemplate = hibernateTemplate; 
    136     } 
     132                Object object = DataAccessUtils.uniqueResult(getHibernateTemplate().find(query, parameters)); 
    137133 
    138     public HibernateTemplate getHibernateTemplate() { 
    139         return hibernateTemplate; 
    140     } 
     134                log.trace("Object unique [{}]", object); 
     135                return object; 
     136        } 
    141137 
    142     public void setSessionFactory(SessionFactory sessionFactory) { 
    143         this.sessionFactory = sessionFactory; 
    144         this.hibernateTemplate = new HibernateTemplate(sessionFactory); 
    145     } 
     138        public void setHibernateTemplate(HibernateTemplate hibernateTemplate) { 
     139                this.hibernateTemplate = hibernateTemplate; 
     140        } 
    146141 
    147     @SuppressWarnings("rawtypes") 
    148     @Override 
    149     public void deleteAllEntries(Collection entries) throws DataAccessException { 
    150         hibernateTemplate.deleteAll(entries); 
     142        public HibernateTemplate getHibernateTemplate() { 
     143                return hibernateTemplate; 
     144        } 
    151145 
    152     } 
     146        public void setSessionFactory(SessionFactory sessionFactory) { 
     147                this.sessionFactory = sessionFactory; 
     148                this.hibernateTemplate = new HibernateTemplate(sessionFactory); 
     149        } 
     150 
     151        @SuppressWarnings("rawtypes") 
     152        @Override 
     153        public void deleteAllEntries(Collection entries) throws DataAccessException { 
     154                hibernateTemplate.deleteAll(entries); 
     155 
     156        } 
    153157 
    154158} 
Note: See TracChangeset for help on using the changeset viewer.