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.dal.bo.som.KnowledgeElementType;
  18 import org.splat.dal.bo.som.ProgressState;
  19 import org.splat.dal.dao.som.KnowledgeElementTypeDAO;
  20 import org.springframework.transaction.annotation.Transactional;
  21
  22 /**
  23  * KnowledgeElementTypeService implementation for working with knowledge types.
  24  *
  25  * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
  26  */
  27 public class KnowledgeElementTypeServiceImpl implements
  28                 KnowledgeElementTypeService {
  29
  30         /**
  31          * Injected knowledge element type DAO.
  32          */
  33         private KnowledgeElementTypeDAO _knowledgeElementTypeDAO;
  34
  35         /**
  36          * Create a knowledge element type with the given name.
  37          *
  38          * @param name
  39          *            the new type name
  40          * @return the created knowledge type
  41          */
  42         public KnowledgeElementType createType(String name) {
  43                 // TODO: Check for duplicate definition
  44                 KnowledgeElementType kelt = new KnowledgeElementType(name);
  45                 getKnowledgeElementTypeDAO().create(kelt);
  46                 return kelt;
  47         }
  48
  49         /**
  50          * Get all knowledge types from the database.
  51          *
  52          * @return the list of all knowledge types
  53          */
  54         public List<KnowledgeElementType> selectAllTypes() {
  55                 return getKnowledgeElementTypeDAO().getAll(Order.asc("rid"));
  56         }
  57
  58         /**
  59          * Get knowledge types which have the given progress state.
  60          *
  61          * @param state
  62          *            the progress state
  63          * @return the list of found knowledge types
  64          */
  65         public List<KnowledgeElementType> selectTypesWhere(ProgressState state) {
  66                 return getKnowledgeElementTypeDAO().getFilteredList(
  67                                 Restrictions.eq("state", state), Order.asc("rid"));
  68         }
  69
  70         /**
  71          * Find a knowledge type by its name.
  72          *
  73          * @param name
  74          *            the knowledge type name
  75          * @return the found knowledge type
  76          */
  77         public KnowledgeElementType selectType(String name) {
  78                 return getKnowledgeElementTypeDAO().findByCriteria(
  79                                 Restrictions.eq("name", name));
  80         }
  81
  82         /**
  83          * Get a knowledge type by its id.
  84          *
  85          * @param index
  86          *            the id of a knowledge type
  87          * @return the found knowledge type
  88          */
  89         public KnowledgeElementType selectType(long index) {
  90                 return getKnowledgeElementTypeDAO().get(index);
  91         }
  92
  93         /**
  94          * Approve the knowledge type.
  95          *
  96          * @param kelt
  97          *            the knowledge type to approve
  98          * @return true if approval succeeded
  99          */
 100         @Transactional
 101         public boolean approve(KnowledgeElementType kelt) {
 102                 if (kelt.getState() != ProgressState.inCHECK)
 103                         return false;
 104                 kelt.setState(ProgressState.APPROVED); // The type name is supposed being localized
 105                 if (kelt.isSaved()) {
 106                         getKnowledgeElementTypeDAO().update(kelt);
 107                 }
 108                 return true;
 109         }
 110
 111         /**
 112          * Reserves this type for the management of simulation contexts. For being able to get the studies in which simulation contexts are
 113          * used, all study scenarios are indexed through this knowledge element type, whether they include knowledge elements or not.
 114          *
 115          * @param kelt
 116          *            the knowledge type to approve
 117          * @return true if approval succeeded
 118          */
 119         @Transactional
 120         public boolean reserve(KnowledgeElementType kelt) {
 121                 if (kelt.getState() != ProgressState.inCHECK)
 122                         return false;
 123                 kelt.setState(ProgressState.inWORK);
 124                 if (kelt.isSaved()) {
 125                         getKnowledgeElementTypeDAO().update(kelt);
 126                 }
 127                 return true;
 128         }
 129
 130         /**
 131          * Get the knowledgeElementTypeDAO.
 132          *
 133          * @return the knowledgeElementTypeDAO
 134          */
 135         public KnowledgeElementTypeDAO getKnowledgeElementTypeDAO() {
 136                 return _knowledgeElementTypeDAO;
 137         }
 138
 139         /**
 140          * Set the knowledgeElementTypeDAO.
 141          *
 142          * @param knowledgeElementTypeDAO
 143          *            the knowledgeElementTypeDAO to set
 144          */
 145         public void setKnowledgeElementTypeDAO(
 146                         KnowledgeElementTypeDAO knowledgeElementTypeDAO) {
 147                 _knowledgeElementTypeDAO = knowledgeElementTypeDAO;
 148         }
 149
 150 }