Workspace/Siman-Common/src/org/splat/service/KnowledgeElementTypeServiceImpl.java

   1 /*****************************************************************************
   2  * Company         OPEN CASCADE
   3  * Application     SIMAN
   4  * File            $Id$
   5  * Creation date   19.10.2012
   6  * @author         $Author$
   7  * @version        $Revision$
   8  * @copyright      OPEN CASCADE 2012
   9  *****************************************************************************/
  10
  11 package org.splat.service;
  12
  13 import java.util.List;
  14
  15 import org.hibernate.criterion.Order;
  16 import org.hibernate.criterion.Restrictions;
  17 import org.splat.common.properties.MessageKeyEnum;
  18 import org.splat.dal.bo.som.KnowledgeElementType;
  19 import org.splat.dal.bo.som.ProgressState;
  20 import org.splat.dal.dao.som.KnowledgeElementTypeDAO;
  21 import org.splat.log.AppLogger;
  22 import org.springframework.transaction.annotation.Transactional;
  23
  24 /**
  25  * KnowledgeElementTypeService implementation for working with knowledge types.
  26  *
  27  * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
  28  */
  29 public class KnowledgeElementTypeServiceImpl implements
  30                 KnowledgeElementTypeService {
  31
  32         /**
  33          * The logger for the service.
  34          */
  35         public final static AppLogger LOG = AppLogger
  36                         .getLogger(KnowledgeElementTypeServiceImpl.class);
  37         /**
  38          * Injected knowledge element type DAO.
  39          */
  40         private KnowledgeElementTypeDAO _knowledgeElementTypeDAO;
  41
  42         /**
  43          * Create a knowledge element type with the given name.
  44          *
  45          * @param name
  46          *            the new type name
  47          * @return the created knowledge type
  48          */
  49         @Transactional
  50         public KnowledgeElementType createType(final String name) {
  51                 KnowledgeElementType kelt = getKnowledgeElementTypeDAO()
  52                                 .findByCriteria(Restrictions.eq("name", name));
  53                 if (kelt == null) {
  54                         kelt = new KnowledgeElementType(name);
  55                         getKnowledgeElementTypeDAO().create(kelt);
  56                 } else {
  57                         LOG.info(MessageKeyEnum.KNT_000001.toString(), name);
  58                 }
  59                 return kelt;
  60         }
  61
  62         /**
  63          * Get all knowledge types from the database.
  64          *
  65          * @return the list of all knowledge types
  66          */
  67         @Transactional
  68         public List<KnowledgeElementType> selectAllTypes() {
  69                 return getKnowledgeElementTypeDAO().getAll(Order.asc("rid"));
  70         }
  71
  72         /**
  73          * Get knowledge types which have the given progress state.
  74          *
  75          * @param state
  76          *            the progress state
  77          * @return the list of found knowledge types
  78          */
  79         @Transactional
  80         public List<KnowledgeElementType> selectTypesWhere(final ProgressState state) {
  81                 return getKnowledgeElementTypeDAO().getFilteredList(
  82                                 Restrictions.eq("state", state), Order.asc("rid"));
  83         }
  84
  85         /**
  86          * Find a knowledge type by its name.
  87          *
  88          * @param name
  89          *            the knowledge type name
  90          * @return the found knowledge type
  91          */
  92         @Transactional
  93         public KnowledgeElementType selectType(final String name) {
  94                 return getKnowledgeElementTypeDAO().findByCriteria(
  95                                 Restrictions.eq("name", name));
  96         }
  97
  98         /**
  99          * Get a knowledge type by its id.
 100          *
 101          * @param index
 102          *            the id of a knowledge type
 103          * @return the found knowledge type
 104          */
 105         @Transactional
 106         public KnowledgeElementType selectType(final long index) {
 107                 return getKnowledgeElementTypeDAO().get(index);
 108         }
 109
 110         /**
 111          * Approve the knowledge type.
 112          *
 113          * @param kelt
 114          *            the knowledge type to approve
 115          * @return true if approval succeeded
 116          */
 117         @Transactional
 118         public boolean approve(final KnowledgeElementType kelt) {
 119                 boolean res = (kelt.getState() == ProgressState.inCHECK);
 120                 if (res) {
 121                         kelt.setState(ProgressState.APPROVED); // The type name is supposed being localized
 122                         if (kelt.isSaved()) {
 123                                 getKnowledgeElementTypeDAO().update(kelt);
 124                         }
 125                 }
 126                 return res;
 127         }
 128
 129         /**
 130          * Reserves this type for the management of simulation contexts. For being able to get the studies in which simulation contexts are
 131          * used, all study scenarios are indexed through this knowledge element type, whether they include knowledge elements or not.
 132          *
 133          * @param kelt
 134          *            the knowledge type to approve
 135          * @return true if approval succeeded
 136          */
 137         @Transactional
 138         public boolean reserve(final KnowledgeElementType kelt) {
 139                 boolean res = (kelt.getState() == ProgressState.inCHECK);
 140                 if (res) {
 141                         kelt.setState(ProgressState.inWORK);
 142                         if (kelt.isSaved()) {
 143                                 getKnowledgeElementTypeDAO().update(kelt);
 144                         }
 145                 }
 146                 return res;
 147         }
 148
 149         /**
 150          * Get the knowledgeElementTypeDAO.
 151          *
 152          * @return the knowledgeElementTypeDAO
 153          */
 154         public KnowledgeElementTypeDAO getKnowledgeElementTypeDAO() {
 155                 return _knowledgeElementTypeDAO;
 156         }
 157
 158         /**
 159          * Set the knowledgeElementTypeDAO.
 160          *
 161          * @param knowledgeElementTypeDAO
 162          *            the knowledgeElementTypeDAO to set
 163          */
 164         public void setKnowledgeElementTypeDAO(
 165                         final KnowledgeElementTypeDAO knowledgeElementTypeDAO) {
 166                 _knowledgeElementTypeDAO = knowledgeElementTypeDAO;
 167         }
 168
 169 }