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

   1 /*****************************************************************************
   2  * Company         OPEN CASCADE
   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.KnowledgeElementType;
  21 import org.splat.dal.bo.som.Publication;
  22 import org.splat.dal.bo.som.Scenario;
  23 import org.splat.dal.bo.som.SimulationContext;
  24 import org.splat.dal.bo.som.Study;
  25 import org.splat.dal.dao.som.KnowledgeElementDAO;
  26 import org.splat.dal.dao.som.ScenarioDAO;
  27 import org.splat.dal.dao.som.StudyDAO;
  28 import org.splat.kernel.InvalidPropertyException;
  29 import org.splat.kernel.MissedPropertyException;
  30 import org.splat.kernel.MultiplyDefinedException;
  31 import org.splat.kernel.UserDirectory;
  32 import org.splat.service.technical.IndexService;
  33 import org.splat.som.Step;
  34 import org.springframework.transaction.annotation.Transactional;
  35
  36 /**
  37  * Scenario service implementation.
  38  *
  39  * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
  40  */
  41 public class ScenarioServiceImpl implements ScenarioService {
  42
  43         /**
  44          * Logger for this class.
  45          */
  46         protected final static Logger logger = Logger
  47                         .getLogger(ScenarioServiceImpl.class);
  48
  49         /**
  50          * Injected index service.
  51          */
  52         private IndexService _indexService;
  53         /**
  54          * Injected step service.
  55          */
  56         private StepService _stepService;
  57         /**
  58          * Injected study service.
  59          */
  60         private StudyService _studyService;
  61         /**
  62          * Injected publication service.
  63          */
  64         private PublicationService _publicationService;
  65         /**
  66          * Injected project element service.
  67          */
  68         private ProjectElementService _projectElementService;
  69         /**
  70          * Injected knowledge element DAO.
  71          */
  72         private KnowledgeElementDAO _knowledgeElementDAO;
  73         /**
  74          * Injected scenario DAO.
  75          */
  76         private ScenarioDAO _scenarioDAO;
  77
  78         /**
  79          * Injected study DAO.
  80          */
  81         private StudyDAO _studyDAO;
  82
  83         /**
  84          * Injected knowledge element service.
  85          */
  86         private KnowledgeElementTypeService _knowledgeElementTypeService;
  87
  88         /**
  89          * Get the projectElementService.
  90          *
  91          * @return the projectElementService
  92          */
  93         public ProjectElementService getProjectElementService() {
  94                 return _projectElementService;
  95         }
  96
  97         /**
  98          * Set the projectElementService.
  99          *
 100          * @param projectElementService
 101          *            the projectElementService to set
 102          */
 103         public void setProjectElementService(
 104                         ProjectElementService projectElementService) {
 105                 _projectElementService = projectElementService;
 106         }
 107
 108         /**
 109          * Get the publicationService.
 110          *
 111          * @return the publicationService
 112          */
 113         public PublicationService getPublicationService() {
 114                 return _publicationService;
 115         }
 116
 117         /**
 118          * Set the publicationService.
 119          *
 120          * @param publicationService
 121          *            the publicationService to set
 122          */
 123         public void setPublicationService(PublicationService publicationService) {
 124                 _publicationService = publicationService;
 125         }
 126
 127         /**
 128          * Get the stepService.
 129          *
 130          * @return the stepService
 131          */
 132         public StepService getStepService() {
 133                 return _stepService;
 134         }
 135
 136         /**
 137          * Set the stepService.
 138          *
 139          * @param stepService
 140          *            the stepService to set
 141          */
 142         public void setStepService(StepService stepService) {
 143                 _stepService = stepService;
 144         }
 145
 146         /**
 147          * {@inheritDoc}
 148          *
 149          * @see org.splat.service.ScenarioService#addKnowledgeElement(org.splat.dal.bo.som.Scenario,
 150          *      org.splat.dal.bo.som.KnowledgeElement.Properties)
 151          */
 152         @Transactional
 153         public KnowledgeElement addKnowledgeElement(Scenario aScenario,
 154                         KnowledgeElement.Properties kprop) throws MissedPropertyException,
 155                         InvalidPropertyException, MultiplyDefinedException {
 156                 KnowledgeElement kelm = null;
 157                 try {
 158                         // Attach the detached scenario to the new hibernate session.
 159                         aScenario = getScenarioDAO().merge(aScenario); // RKV
 160                         kelm = new KnowledgeElement(kprop.setOwnerScenario(aScenario));
 161                         getKnowledgeElementDAO().create(kelm);
 162                         // RKV: commented because of BatchUpdateException during creation of a new study: session.flush(); //RKV
 163                         // Update of my persistent data
 164                         // RKV aScenario.getKnowledgeElements().add(kelm);
 165                         // RKV getKnowledgeElementDAO().flush();
 166                         // RKV: commented because of NullPointerException during creation of a new study: session.merge(aScenario); //RKV
 167                         // Update of my transient data
 168                         List<KnowledgeElement> known = aScenario
 169                                         .getKnowledgeElementsOf(kelm.getType()); // Initializes this.known, if not yet done
 170                         // RKV: knowledge is already added into persistent set and "known" is constructed from it in the above call: known.add(kelm);
 171                         if (kelm.getType().equals("usecase")) {
 172                                 aScenario.setUcase(kelm);
 173                         } else if (aScenario.getKnowledgeElementsList() != null) { // If null, knowl will be initialized when needed
 174                                 aScenario.getKnowledgeElementsList().add(kelm);
 175                         }
 176                         // Update of the index of Knowledge Elements
 177                         getIndexService().add(kelm);
 178                         update(aScenario);
 179
 180                 } catch (IOException error) {
 181                         logger.error("Unable to index the knowedge element '"
 182                                         + kelm.getIndex() + "', reason:", error);
 183                         kelm = null;
 184                 }
 185
 186                 return kelm;
 187         }
 188
 189         /**
 190          * Update the scenario in the database.
 191          *
 192          * @param aScenario
 193          *            the scenario to update
 194          * @return true if updating succeeded
 195          */
 196         @Transactional
 197         private boolean update(Scenario aScenario) {
 198                 boolean isOk = false;
 199                 try {
 200                         getScenarioDAO().update(aScenario); // Update of relational base
 201                         isOk = true;
 202                 } catch (Exception error) {
 203                         logger.error("Unable to re-index the knowledge element '"
 204                                         + aScenario.getIndex() + "', reason:", error);
 205                 }
 206                 return isOk;
 207         }
 208
 209         /**
 210          * {@inheritDoc}
 211          *
 212          * @see org.splat.service.ScenarioService#checkin(org.splat.dal.bo.som.Scenario)
 213          */
 214         public void checkin(Scenario aScenario) {
 215                 aScenario.setUser(null);
 216                 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
 217                 getScenarioDAO().update(aScenario);
 218         }
 219
 220         /**
 221          * {@inheritDoc}
 222          *
 223          * @see org.splat.service.ScenarioService#checkout(org.splat.dal.bo.som.Scenario, org.splat.dal.bo.kernel.User)
 224          */
 225         public boolean checkout(Scenario aScenario, User user) {
 226                 if (!getStudyService().isStaffedBy(aScenario.getOwnerStudy(), user))
 227                         return false;
 228
 229                 aScenario.setUser(user);
 230                 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
 231                 getScenarioDAO().update(aScenario);
 232                 return true;
 233         }
 234
 235         /**
 236          * {@inheritDoc}
 237          *
 238          * @see org.splat.service.ScenarioService#copyContentsUpTo(org.splat.dal.bo.som.Scenario, org.splat.som.Step)
 239          */
 240         public void copyContentsUpTo(Scenario scenario, Step lastep) {
 241                 Scenario base = (Scenario) lastep.getOwner();
 242                 Step[] from = getProjectElementService().getSteps(base);
 243                 Step[] to = getProjectElementService().getSteps(scenario);
 244                 for (int i = 0; i < from.length; i++) {
 245                         Step step = from[i];
 246                         if (step.getNumber() > lastep.getNumber())
 247                                 break;
 248
 249                         List<Publication> docs = step.getAllDocuments();
 250                         for (Iterator<Publication> j = docs.iterator(); j.hasNext();) {
 251                                 Publication doc = getPublicationService().copy(j.next(),
 252                                                 scenario); // Creation of a new reference to the document
 253                                 // Database.getSession().save(doc); Publications MUST be saved later through cascading when saving the scenario
 254                                 getStepService().add(to[i], doc);
 255                         }
 256                         List<SimulationContext> ctex = step.getAllSimulationContexts();
 257                         for (Iterator<SimulationContext> j = ctex.iterator(); j.hasNext();) {
 258                                 getStepService().addSimulationContext(to[i], j.next());
 259                         }
 260                 }
 261         }
 262
 263         /**
 264          * {@inheritDoc}
 265          *
 266          * @see org.splat.service.ScenarioService#isEmpty(org.splat.dal.bo.som.Scenario)
 267          */
 268         public boolean isEmpty(Scenario scenario) {
 269                 Step[] mystep = getProjectElementService().getSteps(scenario);
 270                 boolean isEmp = true;
 271                 for (int i = 0; i < mystep.length; i++) {
 272                         if (mystep[i].isStarted()) {
 273                                 isEmp = false;
 274                                 break;
 275                         }
 276                 }
 277                 return isEmp;
 278         }
 279
 280         /**
 281          * @param scenario
 282          * @return
 283          */
 284         public boolean isFinished(Scenario scenario) {
 285                 Step[] mystep = getProjectElementService().getSteps(scenario);
 286                 boolean notempty = false; // If this is empty, this is not finished
 287                 for (int i = 0; i < mystep.length; i++) {
 288                         if (!mystep[i].isStarted())
 289                                 continue;
 290                         if (!mystep[i].isFinished())
 291                                 return false;
 292                         notempty = true;
 293                 }
 294                 return notempty;
 295         }
 296
 297         /**
 298          * {@inheritDoc}
 299          *
 300          * @see org.splat.service.StudyService#addScenario(org.splat.dal.bo.som.Study, org.splat.dal.bo.som.Scenario.Properties)
 301          */
 302         @Transactional
 303         public Scenario addScenario(Study aStudy, Scenario.Properties sprop)
 304                         throws MissedPropertyException, InvalidPropertyException,
 305                         MultiplyDefinedException {
 306                 if (sprop.getManager() == null)
 307                         sprop.setManager(aStudy.getAuthor());
 308
 309                 Scenario scenario = new Scenario(sprop.setOwnerStudy(aStudy));
 310                 if (sprop.getBaseStep() != null)
 311                         copyContentsUpTo(scenario, sprop.getBaseStep());
 312                 Scenario previous = sprop.getInsertAfter();
 313
 314                 if (previous == null) {
 315                         aStudy.getScenariiList().add(scenario);
 316                 } else {
 317                         aStudy.getScenariiList().add(
 318                                         aStudy.getScenariiList().indexOf(previous) + 1, scenario);
 319                 }
 320                 getStudyDAO().update(aStudy); // No need to update the Lucene index
 321                 getScenarioDAO().create(scenario); // Must be done after updating this study because of the back reference to the study
 322                 if (sprop.getBaseStep() != null) {
 323                         // No need to update the Knowledge Element index as Knowledge Elements are not copied
 324                         scenario.refresh(); // Because saving the scenario changes the hashcode of copied Publications
 325                 }
 326                 KnowledgeElementType ucase = getKnowledgeElementTypeService().selectType(
 327                                 "usecase");
 328                 KnowledgeElement.Properties kprop = new KnowledgeElement.Properties();
 329                 User admin = UserDirectory.selectUser(1); // First user created when creating the database
 330                 kprop.setType(ucase).setTitle(aStudy.getTitle()).setValue(
 331                                 scenario.getTitle()).setAuthor(admin); // Internal Knowledge Element required by the validation process of
 332                 // knowledges
 333                 addKnowledgeElement(scenario, kprop);
 334                 return scenario;
 335         }
 336
 337         /**
 338          * Get the knowledgeElementDAO.
 339          *
 340          * @return the knowledgeElementDAO
 341          */
 342         public KnowledgeElementDAO getKnowledgeElementDAO() {
 343                 return _knowledgeElementDAO;
 344         }
 345
 346         /**
 347          * Set the knowledgeElementDAO.
 348          *
 349          * @param knowledgeElementDAO
 350          *            the knowledgeElementDAO to set
 351          */
 352         public void setKnowledgeElementDAO(KnowledgeElementDAO knowledgeElementDAO) {
 353                 _knowledgeElementDAO = knowledgeElementDAO;
 354         }
 355
 356         /**
 357          * Get the indexService.
 358          *
 359          * @return the indexService
 360          */
 361         public IndexService getIndexService() {
 362                 return _indexService;
 363         }
 364
 365         /**
 366          * Set the indexService.
 367          *
 368          * @param indexService
 369          *            the indexService to set
 370          */
 371         public void setIndexService(IndexService indexService) {
 372                 _indexService = indexService;
 373         }
 374
 375         /**
 376          * Get the scenarioDAO.
 377          *
 378          * @return the scenarioDAO
 379          */
 380         public ScenarioDAO getScenarioDAO() {
 381                 return _scenarioDAO;
 382         }
 383
 384         /**
 385          * Set the scenarioDAO.
 386          *
 387          * @param scenarioDAO
 388          *            the scenarioDAO to set
 389          */
 390         public void setScenarioDAO(ScenarioDAO scenarioDAO) {
 391                 _scenarioDAO = scenarioDAO;
 392         }
 393
 394         /**
 395          * Get the studyDAO.
 396          *
 397          * @return the studyDAO
 398          */
 399         public StudyDAO getStudyDAO() {
 400                 return _studyDAO;
 401         }
 402
 403         /**
 404          * Set the studyDAO.
 405          *
 406          * @param studyDAO
 407          *            the studyDAO to set
 408          */
 409         public void setStudyDAO(StudyDAO studyDAO) {
 410                 _studyDAO = studyDAO;
 411         }
 412
 413         /**
 414          * Get the knowledgeElementTypeService.
 415          *
 416          * @return the knowledgeElementTypeService
 417          */
 418         public KnowledgeElementTypeService getKnowledgeElementTypeService() {
 419                 return _knowledgeElementTypeService;
 420         }
 421
 422         /**
 423          * Set the knowledgeElementTypeService.
 424          *
 425          * @param knowledgeElementTypeService
 426          *            the knowledgeElementTypeService to set
 427          */
 428         public void setKnowledgeElementTypeService(
 429                         KnowledgeElementTypeService knowledgeElementTypeService) {
 430                 _knowledgeElementTypeService = knowledgeElementTypeService;
 431         }
 432
 433         /**
 434          * Get the studyService.
 435          * @return the studyService
 436          */
 437         public StudyService getStudyService() {
 438                 return _studyService;
 439         }
 440
 441         /**
 442          * Set the studyService.
 443          * @param studyService the studyService to set
 444          */
 445         public void setStudyService(StudyService studyService) {
 446                 _studyService = studyService;
 447         }
 448
 449 }