Coverage Report - org.jtheque.films.persistence.dao.impl.DaoRealizers
 
Classes in this File Line Coverage Branch Coverage Complexity
DaoRealizers
0 %
0/26
0 %
0/10
1.308
DaoRealizers$1
N/A
N/A
1.308
DaoRealizers$RealizerQueryMapper
0 %
0/9
N/A
1.308
DaoRealizers$RealizerRowMapper
0 %
0/8
N/A
1.308
 
 1  
 package org.jtheque.films.persistence.dao.impl;
 2  
 
 3  
 /*
 4  
  * This file is part of JTheque.
 5  
  *
 6  
  * JTheque is free software: you can redistribute it and/or modify
 7  
  * it under the terms of the GNU General Public License as published by
 8  
  * the Free Software Foundation, either version 3 of the License.
 9  
  *
 10  
  * JTheque is distributed in the hope that it will be useful,
 11  
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12  
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13  
  * GNU General Public License for more details.
 14  
  *
 15  
  * You should have received a copy of the GNU General Public License
 16  
  * along with JTheque.  If not, see <http://www.gnu.org/licenses/>.
 17  
  */
 18  
 
 19  
 import org.jtheque.core.managers.persistence.Entity;
 20  
 import org.jtheque.core.managers.persistence.GenericDao;
 21  
 import org.jtheque.core.managers.persistence.Query;
 22  
 import org.jtheque.core.managers.persistence.QueryMapper;
 23  
 import org.jtheque.core.managers.persistence.context.IDaoPersistenceContext;
 24  
 import org.jtheque.core.utils.db.DaoNotes;
 25  
 import org.jtheque.core.utils.db.DaoNotes.NoteType;
 26  
 import org.jtheque.films.persistence.dao.able.IDaoRealizers;
 27  
 import org.jtheque.films.persistence.od.RealizerImpl;
 28  
 import org.jtheque.primary.dao.able.IDaoCountries;
 29  
 import org.springframework.jdbc.core.simple.ParameterizedRowMapper;
 30  
 import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
 31  
 
 32  
 import javax.annotation.Resource;
 33  
 import java.sql.ResultSet;
 34  
 import java.sql.SQLException;
 35  
 import java.util.List;
 36  
 
 37  
 /**
 38  
  * Cette classe permet de g�rer la persistance des r�alisateurs.
 39  
  *
 40  
  * @author Baptiste Wicht
 41  
  */
 42  0
 public final class DaoRealizers extends GenericDao<RealizerImpl> implements IDaoRealizers {
 43  0
     private final ParameterizedRowMapper<RealizerImpl> rowMapper = new RealizerRowMapper();
 44  0
     private final QueryMapper queryMapper = new RealizerQueryMapper();
 45  
 
 46  
     @Resource
 47  
     private IDaoPersistenceContext persistenceContext;
 48  
 
 49  
     @Resource
 50  
     private IDaoCountries daoCountries;
 51  
 
 52  
     @Resource
 53  
     private SimpleJdbcTemplate jdbcTemplate;
 54  
 
 55  
     /**
 56  
      * Construct a new DaoRealizers.
 57  
      */
 58  
     public DaoRealizers() {
 59  0
         super(TABLE);
 60  0
     }
 61  
 
 62  
     @Override
 63  
     public List<RealizerImpl> getRealizers() {
 64  0
         return getAll();
 65  
     }
 66  
 
 67  
     @Override
 68  
     public boolean exist(RealizerImpl realizer) {
 69  0
         return getRealizer(realizer.getFirstName(), realizer.getName()) != null;
 70  
     }
 71  
 
 72  
     @Override
 73  
     public RealizerImpl getRealizer(int id) {
 74  0
         return get(id);
 75  
     }
 76  
 
 77  
     @Override
 78  
     public RealizerImpl getRealizer(String firstName, String name) {
 79  0
         List<RealizerImpl> realizers = jdbcTemplate.query("SELECT * FROM " + TABLE + " WHERE NAME = ? AND FIRSTNAME = ?", rowMapper, name, firstName);
 80  
         
 81  0
         if(realizers.isEmpty()){
 82  0
             return null;
 83  
         }
 84  
         
 85  0
         RealizerImpl realizer = realizers.get(0);
 86  
         
 87  0
         if (isNotInCache(realizer.getId())) {
 88  0
             getCache().put(realizer.getId(), realizer);
 89  
         }
 90  
 
 91  0
         return getCache().get(realizer.getId());
 92  
     }
 93  
 
 94  
     @Override
 95  
     public boolean exists(String name, String lastName) {
 96  0
         return getRealizer(name, lastName) != null;
 97  
     }
 98  
 
 99  
     @Override
 100  
     protected ParameterizedRowMapper<RealizerImpl> getRowMapper() {
 101  0
         return rowMapper;
 102  
     }
 103  
 
 104  
     @Override
 105  
     protected QueryMapper getQueryMapper() {
 106  0
         return queryMapper;
 107  
     }
 108  
 
 109  
     @Override
 110  
     protected void loadCache() {
 111  0
         List<RealizerImpl> realizers = persistenceContext.getSortedList(TABLE, rowMapper);
 112  
 
 113  0
         for (RealizerImpl realizer : realizers) {
 114  0
             getCache().put(realizer.getId(), realizer);
 115  
         }
 116  
 
 117  0
         setCacheEntirelyLoaded(true);
 118  0
     }
 119  
 
 120  
     @Override
 121  
     protected void load(int i) {
 122  0
         RealizerImpl realizer = persistenceContext.getDataByID(TABLE, i, rowMapper);
 123  
 
 124  0
         getCache().put(i, realizer);
 125  0
     }
 126  
 
 127  
     /**
 128  
      * A row mapper to map resultset to realizer.
 129  
      *
 130  
      * @author Baptiste Wicht
 131  
      */
 132  0
     private final class RealizerRowMapper implements ParameterizedRowMapper<RealizerImpl> {
 133  
         @Override
 134  
         public RealizerImpl mapRow(ResultSet rs, int i) throws SQLException {
 135  0
             RealizerImpl realizer = new RealizerImpl();
 136  
 
 137  0
             realizer.setId(rs.getInt("ID"));
 138  0
             realizer.setName(rs.getString("NAME"));
 139  0
             realizer.setFirstName(rs.getString("FIRSTNAME"));
 140  0
             realizer.setTheCountry(daoCountries.getCountry(rs.getInt("THE_COUNTRY_FK")));
 141  0
             realizer.setNote(DaoNotes.getINSTANCE().getNote(NoteType.getEnum(rs.getInt("NOTE"))));
 142  
 
 143  0
             return realizer;
 144  
         }
 145  
     }
 146  
 
 147  
     /**
 148  
      * A query mapper to map realizer to sql query.
 149  
      *
 150  
      * @author Baptiste Wicht
 151  
      */
 152  0
     private static final class RealizerQueryMapper implements QueryMapper {
 153  
         @Override
 154  
         public Query constructInsertQuery(Entity entity) {
 155  0
             RealizerImpl realizer = (RealizerImpl) entity;
 156  
 
 157  0
             String query = "INSERT INTO " + TABLE + " (NAME, FIRSTNAME, THE_COUNTRY_FK, NOTE) VALUES(?,?,?,?)";
 158  
 
 159  0
             Object[] parameters = {
 160  
                     realizer.getName(),
 161  
                     realizer.getFirstName(),
 162  
                     realizer.getTheCountry().getId(),
 163  
                     realizer.getNote().getValue().intValue()
 164  
             };
 165  
 
 166  0
             return new Query(query, parameters);
 167  
         }
 168  
 
 169  
         @Override
 170  
         public Query constructUpdateQuery(Entity entity) {
 171  0
             RealizerImpl realizer = (RealizerImpl) entity;
 172  
 
 173  0
             String query = "UPDATE " + TABLE + " SET NAME = ?, FIRSTNAME = ?, THE_COUNTRY_FK = ?, NOTE = ? WHERE ID = ?";
 174  
 
 175  0
             Object[] parameters = {
 176  
                     realizer.getName(),
 177  
                     realizer.getFirstName(),
 178  
                     realizer.getTheCountry().getId(),
 179  
                     realizer.getNote().getValue().intValue(),
 180  
                     realizer.getId()};
 181  
 
 182  0
             return new Query(query, parameters);
 183  
         }
 184  
     }
 185  
 }