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

   1 /*****************************************************************************
   2  * Company         EURIWARE
   3  * Application     SIMAN
   4  * File            $Id$
   5  * Creation date   06.10.2012
   6  * @author         $Author$
   7  * @version        $Revision$
   8  *****************************************************************************/
   9
  10 package org.splat.service;
  11
  12 import java.io.IOException;
  13 import java.util.Calendar;
  14 import java.util.Iterator;
  15 import java.util.List;
  16
  17 import org.apache.log4j.Logger;
  18 import org.splat.dal.bo.kernel.User;
  19 import org.splat.dal.bo.som.KnowledgeElement;
  20 import org.splat.dal.bo.som.Publication;
  21 import org.splat.dal.bo.som.Scenario;
  22 import org.splat.dal.bo.som.SimulationContext;
  23 import org.splat.dal.dao.som.KnowledgeElementDAO;
  24 import org.splat.dal.dao.som.ScenarioDAO;
  25 import org.splat.kernel.InvalidPropertyException;
  26 import org.splat.kernel.MissedPropertyException;
  27 import org.splat.kernel.MultiplyDefinedException;
  28 import org.splat.service.technical.IndexService;
  29 import org.splat.som.Step;
  30 import org.springframework.transaction.annotation.Transactional;
  31
  32 /**
  33  * Scenario service implementation.
  34  *
  35  * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
  36  */
  37 public class ScenarioServiceImpl implements ScenarioService {
  38
  39         /**
  40          * Logger for this class.
  41          */
  42         protected final static Logger logger = Logger
  43                         .getLogger(ScenarioServiceImpl.class);
  44
  45         /**
  46          * Injected index service.
  47          */
  48         private IndexService _indexService;
  49         /**
  50          * Injected step service.
  51          */
  52         private StepService _stepService;
  53         /**
  54          * Injected publication service.
  55          */
  56         private PublicationService _publicationService;
  57         /**
  58          * Injected project element service.
  59          */
  60         private ProjectElementService _projectElementService;
  61         /**
  62          * Injected knowledge element DAO.
  63          */
  64         private KnowledgeElementDAO _knowledgeElementDAO;
  65         /**
  66          * Injected scenario DAO.
  67          */
  68         private ScenarioDAO _scenarioDAO;
  69
  70         /**
  71          * Get the projectElementService.
  72          *
  73          * @return the projectElementService
  74          */
  75         public ProjectElementService getProjectElementService() {
  76                 return _projectElementService;
  77         }
  78
  79         /**
  80          * Set the projectElementService.
  81          *
  82          * @param projectElementService
  83          *            the projectElementService to set
  84          */
  85         public void setProjectElementService(
  86                         ProjectElementService projectElementService) {
  87                 _projectElementService = projectElementService;
  88         }
  89
  90         /**
  91          * Get the publicationService.
  92          *
  93          * @return the publicationService
  94          */
  95         public PublicationService getPublicationService() {
  96                 return _publicationService;
  97         }
  98
  99         /**
 100          * Set the publicationService.
 101          *
 102          * @param publicationService
 103          *            the publicationService to set
 104          */
 105         public void setPublicationService(PublicationService publicationService) {
 106                 _publicationService = publicationService;
 107         }
 108
 109         /**
 110          * Get the stepService.
 111          *
 112          * @return the stepService
 113          */
 114         public StepService getStepService() {
 115                 return _stepService;
 116         }
 117
 118         /**
 119          * Set the stepService.
 120          *
 121          * @param stepService
 122          *            the stepService to set
 123          */
 124         public void setStepService(StepService stepService) {
 125                 _stepService = stepService;
 126         }
 127
 128         /**
 129          * {@inheritDoc}
 130          *
 131          * @see org.splat.service.ScenarioService#addKnowledgeElement(org.splat.dal.bo.som.Scenario,
 132          *      org.splat.dal.bo.som.KnowledgeElement.Properties)
 133          */
 134         @Transactional
 135         public KnowledgeElement addKnowledgeElement(Scenario aScenario,
 136                         KnowledgeElement.Properties kprop) throws MissedPropertyException,
 137                         InvalidPropertyException, MultiplyDefinedException {
 138                 KnowledgeElement kelm = new KnowledgeElement(kprop
 139                                 .setOwnerScenario(aScenario));
 140                 try {
 141                         getKnowledgeElementDAO().create(kelm);
 142                         // RKV: commented because of BatchUpdateException during creation of a new study: session.flush(); //RKV
 143                         // Update of my persistent data
 144                         aScenario.getKnowledgeElements().add(kelm);
 145                         // RKV: commented because of NullPointerException during creation of a new study: session.merge(aScenario); //RKV
 146                         // Update of my transient data
 147                         List<KnowledgeElement> known = aScenario
 148                                         .getKnowledgeElementsOf(kelm.getType()); // Initializes this.known, if not yet done
 149                         known.add(kelm);
 150                         if (kelm.getType().equals("usecase")) {
 151                                 aScenario.setUcase(kelm);
 152                         } else if (aScenario.getKnowledgeElementsList() != null) { // If null, knowl will be initialized when needed
 153                                 aScenario.getKnowledgeElementsList().add(kelm);
 154                         }
 155                         // Update of the index of Knowledge Elements
 156                         getIndexService().add(kelm);
 157                         update(aScenario);
 158
 159                 } catch (IOException error) {
 160                         logger.error("Unable to index the knowedge element '"
 161                                         + kelm.getIndex() + "', reason:", error);
 162                         kelm = null;
 163                 }
 164
 165                 return kelm;
 166         }
 167
 168         /**
 169          * Update the scenario in the database.
 170          *
 171          * @param aScenario
 172          *            the scenario to update
 173          * @return true if updating succeeded
 174          */
 175         @Transactional
 176         private boolean update(Scenario aScenario) {
 177                 boolean isOk = false;
 178                 try {
 179                         getScenarioDAO().update(aScenario); // Update of relational base
 180                         isOk = true;
 181                 } catch (Exception error) {
 182                         logger.error("Unable to re-index the knowledge element '"
 183                                         + aScenario.getIndex() + "', reason:", error);
 184                 }
 185                 return isOk;
 186         }
 187
 188         /**
 189          * {@inheritDoc}
 190          *
 191          * @see org.splat.service.ScenarioService#checkin(org.splat.dal.bo.som.Scenario)
 192          */
 193         public void checkin(Scenario aScenario) {
 194                 aScenario.setUser(null);
 195                 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
 196                 getScenarioDAO().update(aScenario);
 197         }
 198
 199         /**
 200          * {@inheritDoc}
 201          *
 202          * @see org.splat.service.ScenarioService#checkout(org.splat.dal.bo.som.Scenario, org.splat.dal.bo.kernel.User)
 203          */
 204         public boolean checkout(Scenario aScenario, User user) {
 205                 if (!aScenario.getOwnerStudy().isStaffedBy(user))
 206                         return false;
 207
 208                 aScenario.setUser(user);
 209                 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
 210                 getScenarioDAO().update(aScenario);
 211                 return true;
 212         }
 213
 214         /**
 215          * {@inheritDoc}
 216          *
 217          * @see org.splat.service.ScenarioService#copyContentsUpTo(org.splat.dal.bo.som.Scenario, org.splat.som.Step)
 218          */
 219         public void copyContentsUpTo(Scenario scenario, Step lastep) {
 220                 Scenario base = (Scenario) lastep.getOwner();
 221                 Step[] from = getProjectElementService().getSteps(base);
 222                 Step[] to = getProjectElementService().getSteps(scenario);
 223                 for (int i = 0; i < from.length; i++) {
 224                         Step step = from[i];
 225                         if (step.getNumber() > lastep.getNumber())
 226                                 break;
 227
 228                         List<Publication> docs = step.getAllDocuments();
 229                         for (Iterator<Publication> j = docs.iterator(); j.hasNext();) {
 230                                 Publication doc = getPublicationService().copy(j.next(),
 231                                                 scenario); // Creation of a new reference to the document
 232                                 // Database.getSession().save(doc); Publications MUST be saved later through cascading when saving the scenario
 233                                 to[i].add(doc);
 234                         }
 235                         List<SimulationContext> ctex = step.getAllSimulationContexts();
 236                         for (Iterator<SimulationContext> j = ctex.iterator(); j.hasNext();) {
 237                                 getStepService().addSimulationContext(to[i], j.next());
 238                         }
 239                 }
 240         }
 241
 242         /**
 243          * {@inheritDoc}
 244          *
 245          * @see org.splat.service.ScenarioService#isEmpty(org.splat.dal.bo.som.Scenario)
 246          */
 247         public boolean isEmpty(Scenario scenario) {
 248                 Step[] mystep = getProjectElementService().getSteps(scenario);
 249                 boolean isEmp = true;
 250                 for (int i = 0; i < mystep.length; i++) {
 251                         if (mystep[i].isStarted()) {
 252                                 isEmp = false;
 253                                 break;
 254                         }
 255                 }
 256                 return isEmp;
 257         }
 258
 259         /**
 260          * @param scenario
 261          * @return
 262          */
 263         public boolean isFinished(Scenario scenario) {
 264                 Step[] mystep = getProjectElementService().getSteps(scenario);
 265                 boolean notempty = false; // If this is empty, this is not finished
 266                 for (int i = 0; i < mystep.length; i++) {
 267                         if (!mystep[i].isStarted())
 268                                 continue;
 269                         if (!mystep[i].isFinished())
 270                                 return false;
 271                         notempty = true;
 272                 }
 273                 return notempty;
 274         }
 275
 276         /**
 277          * Get the knowledgeElementDAO.
 278          *
 279          * @return the knowledgeElementDAO
 280          */
 281         public KnowledgeElementDAO getKnowledgeElementDAO() {
 282                 return _knowledgeElementDAO;
 283         }
 284
 285         /**
 286          * Set the knowledgeElementDAO.
 287          *
 288          * @param knowledgeElementDAO
 289          *            the knowledgeElementDAO to set
 290          */
 291         public void setKnowledgeElementDAO(KnowledgeElementDAO knowledgeElementDAO) {
 292                 _knowledgeElementDAO = knowledgeElementDAO;
 293         }
 294
 295         /**
 296          * Get the indexService.
 297          *
 298          * @return the indexService
 299          */
 300         public IndexService getIndexService() {
 301                 return _indexService;
 302         }
 303
 304         /**
 305          * Set the indexService.
 306          *
 307          * @param indexService
 308          *            the indexService to set
 309          */
 310         public void setIndexService(IndexService indexService) {
 311                 _indexService = indexService;
 312         }
 313
 314         /**
 315          * Get the scenarioDAO.
 316          *
 317          * @return the scenarioDAO
 318          */
 319         public ScenarioDAO getScenarioDAO() {
 320                 return _scenarioDAO;
 321         }
 322
 323         /**
 324          * Set the scenarioDAO.
 325          *
 326          * @param scenarioDAO
 327          *            the scenarioDAO to set
 328          */
 329         public void setScenarioDAO(ScenarioDAO scenarioDAO) {
 330                 _scenarioDAO = scenarioDAO;
 331         }
 332
 333 }