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.ArrayList;
  14 import java.util.Calendar;
  15 import java.util.Iterator;
  16 import java.util.List;
  17
  18 import org.apache.log4j.Logger;
  19 import org.splat.dal.bo.kernel.Relation;
  20 import org.splat.dal.bo.kernel.User;
  21 import org.splat.dal.bo.som.ConvertsRelation;
  22 import org.splat.dal.bo.som.File;
  23 import org.splat.dal.bo.som.KnowledgeElement;
  24 import org.splat.dal.bo.som.KnowledgeElementType;
  25 import org.splat.dal.bo.som.Publication;
  26 import org.splat.dal.bo.som.Scenario;
  27 import org.splat.dal.bo.som.SimulationContext;
  28 import org.splat.dal.bo.som.Study;
  29 import org.splat.dal.dao.kernel.UserDAO;
  30 import org.splat.dal.dao.som.KnowledgeElementDAO;
  31 import org.splat.dal.dao.som.KnowledgeElementTypeDAO;
  32 import org.splat.dal.dao.som.ScenarioDAO;
  33 import org.splat.dal.dao.som.StudyDAO;
  34 import org.splat.kernel.InvalidPropertyException;
  35 import org.splat.kernel.MissedPropertyException;
  36 import org.splat.kernel.MultiplyDefinedException;
  37 import org.splat.service.dto.DocumentDTO;
  38 import org.splat.service.dto.StepDTO;
  39 import org.splat.service.technical.IndexService;
  40 import org.splat.som.Step;
  41 import org.splat.util.BeanHelper;
  42 import org.springframework.transaction.annotation.Transactional;
  43
  44 /**
  45  * Scenario service implementation.
  46  *
  47  * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
  48  */
  49 public class ScenarioServiceImpl implements ScenarioService {
  50
  51         /**
  52          * Logger for this class.
  53          */
  54         protected final static Logger LOG = Logger
  55                         .getLogger(ScenarioServiceImpl.class);
  56
  57         /**
  58          * Injected index service.
  59          */
  60         private IndexService _indexService;
  61         /**
  62          * Injected step service.
  63          */
  64         private StepService _stepService;
  65         /**
  66          * Injected study service.
  67          */
  68         private StudyService _studyService;
  69         /**
  70          * Injected publication service.
  71          */
  72         private PublicationService _publicationService;
  73         /**
  74          * Injected project element service.
  75          */
  76         private ProjectElementService _projectElementService;
  77         /**
  78          * Injected knowledge element DAO.
  79          */
  80         private KnowledgeElementDAO _knowledgeElementDAO;
  81         /**
  82          * Injected scenario DAO.
  83          */
  84         private ScenarioDAO _scenarioDAO;
  85
  86         /**
  87          * Injected study DAO.
  88          */
  89         private StudyDAO _studyDAO;
  90
  91         /**
  92          * Injected knowledge element service.
  93          */
  94         private KnowledgeElementTypeService _knowledgeElementTypeService;
  95
  96         /**
  97          * Injected user service.
  98          */
  99         private UserService _userService;
 100
 101         /**
 102          * Injected user DAO.
 103          */
 104         private UserDAO _userDAO;
 105
 106         /**
 107          * Injected knowledge element type DAO.
 108          */
 109         private KnowledgeElementTypeDAO _knowledgeElementTypeDAO;
 110
 111         /**
 112          * Injected simulation context service.
 113          */
 114         private SimulationContextService _simulationContextService;
 115
 116         /**
 117          * Get the projectElementService.
 118          *
 119          * @return the projectElementService
 120          */
 121         public ProjectElementService getProjectElementService() {
 122                 return _projectElementService;
 123         }
 124
 125         /**
 126          * Set the projectElementService.
 127          *
 128          * @param projectElementService
 129          *            the projectElementService to set
 130          */
 131         public void setProjectElementService(
 132                         final ProjectElementService projectElementService) {
 133                 _projectElementService = projectElementService;
 134         }
 135
 136         /**
 137          * Get the publicationService.
 138          *
 139          * @return the publicationService
 140          */
 141         public PublicationService getPublicationService() {
 142                 return _publicationService;
 143         }
 144
 145         /**
 146          * Set the publicationService.
 147          *
 148          * @param publicationService
 149          *            the publicationService to set
 150          */
 151         public void setPublicationService(final PublicationService publicationService) {
 152                 _publicationService = publicationService;
 153         }
 154
 155         /**
 156          * Get the stepService.
 157          *
 158          * @return the stepService
 159          */
 160         public StepService getStepService() {
 161                 return _stepService;
 162         }
 163
 164         /**
 165          * Set the stepService.
 166          *
 167          * @param stepService
 168          *            the stepService to set
 169          */
 170         public void setStepService(final StepService stepService) {
 171                 _stepService = stepService;
 172         }
 173
 174         /**
 175          * {@inheritDoc}
 176          * @see org.splat.service.ScenarioService#getScenarioInfo(long)
 177          */
 178         @Transactional
 179         public List<StepDTO> getScenarioInfo(final long scenarioId) {
 180                 List<StepDTO> res = new ArrayList<StepDTO>();
 181                 Scenario scen = getScenarioDAO().get(scenarioId);
 182                 Step[] steps = getProjectElementService().getSteps(scen);
 183                 StepDTO stepDTO;
 184                 DocumentDTO docDTO;
 185                 for (Step step: steps) {
 186                         stepDTO = BeanHelper.copyBean(step.getStep(), StepDTO.class);
 187                         res.add(stepDTO);
 188                         for (Publication tag: step.getDocuments()) {
 189                                 docDTO = stepDTO.addDoc(tag.value().getIndex(), tag.value().getTitle());
 190                                 char aState = tag.getIsnew();
 191                                 docDTO.addFile(tag.value().getFile().getRelativePath(), aState);
 192                                 for(Relation rel: tag.value().getRelations(ConvertsRelation.class)) {
 193                                         File aFile = ((ConvertsRelation)rel).getTo();
 194                                         docDTO.addFile(aFile.getRelativePath(), aState);
 195                                 }
 196                         }
 197                 }
 198                 return res;
 199         }
 200
 201         /**
 202          * Create a new study with one scenario and "product" simulation context.
 203          *
 204          * @param sprop
 205          *            the study properties
 206          * @param oprop
 207          *            the scenario properties
 208          * @param cprop
 209          *            the "product" simulation context properties
 210          * @return the created study
 211          * @throws MissedPropertyException
 212          *             if a mandatory property is missed
 213          * @throws InvalidPropertyException
 214          *             if a property is invalid
 215          * @throws MultiplyDefinedException
 216          *             if some property occurs several times
 217          */
 218         @Transactional
 219         public Study createStudy(final Study.Properties sprop, final Scenario.Properties oprop,
 220                         final SimulationContext.Properties cprop) throws MissedPropertyException,
 221                         InvalidPropertyException, MultiplyDefinedException {
 222                 Study study = getStudyService().createStudy(sprop);
 223                 addScenario(study, oprop);
 224                 if (cprop.getIndex() == 0) { // Input of new project context
 225                         cprop.setType(getSimulationContextService().selectType("product"))
 226                                         .setValue(cprop.getValue());
 227                         getStudyService().addProjectContext(study, cprop);
 228                 } else { // Selection of existing project context
 229                         SimulationContext context = getSimulationContextService()
 230                                         .selectSimulationContext(cprop.getIndex());
 231                         getStudyService().addProjectContext(study, context);
 232                 }
 233                 return study;
 234         }
 235
 236         /**
 237          * {@inheritDoc}
 238          *
 239          * @see org.splat.service.ScenarioService#addKnowledgeElement(org.splat.dal.bo.som.Scenario,
 240          *      org.splat.dal.bo.som.KnowledgeElement.Properties)
 241          */
 242         @Transactional
 243         public KnowledgeElement addKnowledgeElement(final Scenario aScenarioDTO,
 244                         final KnowledgeElement.Properties kprop) throws MissedPropertyException,
 245                         InvalidPropertyException, MultiplyDefinedException {
 246                 KnowledgeElement kelm = null;
 247                 try {
 248                         long aScenarioId = aScenarioDTO.getIndex();
 249                         if (LOG.isDebugEnabled()) {
 250                                 LOG.debug("Add a knowledge element to the scenario #"
 251                                                 + aScenarioId);
 252                         }
 253                         // Get the persistent scenario.
 254                         Scenario aScenario = getScenarioDAO().get(aScenarioId);
 255                         // Get persistent objects for creating a new knowledge.
 256                         // TODO: Actions must use DTO instead of persistent objects.
 257                         getUserDAO().merge(kprop.getAuthor());
 258                         getKnowledgeElementTypeDAO().merge(kprop.getType());
 259                         // Create a transient knowledge element related to the given scenario.
 260                         kelm = new KnowledgeElement(kprop.setOwnerScenario(aScenario));
 261                         // Save the new knowledge in the database.
 262                         getKnowledgeElementDAO().create(kelm);
 263                         // Update scenario transient data.
 264                         if (kelm.getType().equals("usecase")) {
 265                                 aScenarioDTO.setUcase(kelm);
 266                         } else if (aScenarioDTO.getKnowledgeElementsList() != null) { // If null, knowl will be initialized when needed
 267                                 aScenarioDTO.getKnowledgeElementsList().add(kelm);
 268                         }
 269
 270                         // Load the workflow for the parent study to take into account
 271                         // all study actors durng reindexing.
 272                         getStudyService().loadWorkflow(aScenario.getOwnerStudy());
 273
 274                         // Update the lucene index of knowledge elements.
 275                         getIndexService().add(kelm);
 276                         if (LOG.isDebugEnabled()) {
 277                                 LOG.debug("A knowledge element #" + kelm.getIndex()
 278                                                 + " is added to the scenario #" + aScenario.getIndex());
 279                         }
 280                 } catch (IOException error) {
 281                         LOG.error("Unable to index the knowedge element '"
 282                                         + kelm.getIndex() + "', reason:", error);
 283                         kelm = null;
 284                 }
 285
 286                 return kelm;
 287         }
 288
 289         /**
 290          * Update the scenario in the database.
 291          *
 292          * @param aScenario
 293          *            the scenario to update
 294          * @return true if updating succeeded
 295          */
 296         @Transactional
 297         private boolean update(final Scenario aScenario) {
 298                 boolean isOk = false;
 299                 try {
 300                         getScenarioDAO().update(aScenario); // Update of relational base
 301                         isOk = true;
 302                 } catch (Exception error) {
 303                         LOG.error("Unable to re-index the knowledge element '"
 304                                         + aScenario.getIndex() + "', reason:", error);
 305                 }
 306                 return isOk;
 307         }
 308
 309         /**
 310          * {@inheritDoc}
 311          *
 312          * @see org.splat.service.ScenarioService#checkin(org.splat.dal.bo.som.Scenario)
 313          */
 314         public void checkin(final Scenario aScenario) {
 315                 aScenario.setUser(null);
 316                 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
 317                 getScenarioDAO().update(aScenario);
 318         }
 319
 320         /**
 321          * {@inheritDoc}
 322          *
 323          * @see org.splat.service.ScenarioService#checkout(org.splat.dal.bo.som.Scenario, org.splat.dal.bo.kernel.User)
 324          */
 325         public boolean checkout(final Scenario aScenario, final User user) {
 326                 if (!getStudyService().isStaffedBy(aScenario.getOwnerStudy(), user)) {
 327                         return false;
 328                 }
 329
 330                 aScenario.setUser(user);
 331                 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
 332                 getScenarioDAO().update(aScenario);
 333                 return true;
 334         }
 335
 336         /**
 337          * {@inheritDoc}
 338          *
 339          * @see org.splat.service.ScenarioService#copyContentsUpTo(org.splat.dal.bo.som.Scenario, org.splat.som.Step)
 340          */
 341         public void copyContentsUpTo(final Scenario scenario, final Step lastep) {
 342                 Scenario base = (Scenario) lastep.getOwner();
 343                 Step[] from = getProjectElementService().getSteps(base);
 344                 Step[] to = getProjectElementService().getSteps(scenario);
 345                 for (int i = 0; i < from.length; i++) {
 346                         Step step = from[i];
 347                         if (step.getNumber() > lastep.getNumber()) {
 348                                 break;
 349                         }
 350
 351                         List<Publication> docs = step.getAllDocuments();
 352                         for (Iterator<Publication> j = docs.iterator(); j.hasNext();) {
 353                                 Publication doc = getPublicationService().copy(j.next(),
 354                                                 scenario); // Creation of a new reference to the document
 355                                 // Database.getSession().save(doc); Publications MUST be saved later through cascading when saving the scenario
 356                                 getStepService().add(to[i], doc);
 357                         }
 358                         List<SimulationContext> ctex = step.getAllSimulationContexts();
 359                         for (Iterator<SimulationContext> j = ctex.iterator(); j.hasNext();) {
 360                                 getStepService().addSimulationContext(to[i], j.next());
 361                         }
 362                 }
 363         }
 364
 365         /**
 366          * {@inheritDoc}
 367          *
 368          * @see org.splat.service.ScenarioService#isEmpty(org.splat.dal.bo.som.Scenario)
 369          */
 370         public boolean isEmpty(final Scenario scenario) {
 371                 Step[] mystep = getProjectElementService().getSteps(scenario);
 372                 boolean isEmp = true;
 373                 for (int i = 0; i < mystep.length; i++) {
 374                         if (mystep[i].isStarted()) {
 375                                 isEmp = false;
 376                                 break;
 377                         }
 378                 }
 379                 return isEmp;
 380         }
 381
 382         /**
 383          * @param scenario
 384          * @return
 385          */
 386         public boolean isFinished(final Scenario scenario) {
 387                 Step[] mystep = getProjectElementService().getSteps(scenario);
 388                 boolean notempty = false; // If this is empty, this is not finished
 389                 for (int i = 0; i < mystep.length; i++) {
 390                         if (!mystep[i].isStarted()) {
 391                                 continue;
 392                         }
 393                         if (!mystep[i].isFinished()) {
 394                                 return false;
 395                         }
 396                         notempty = true;
 397                 }
 398                 return notempty;
 399         }
 400
 401         /**
 402          * {@inheritDoc}
 403          *
 404          * @see org.splat.service.StudyService#addScenario(org.splat.dal.bo.som.Study, org.splat.dal.bo.som.Scenario.Properties)
 405          */
 406         @Transactional
 407         public Scenario addScenario(final Study aStudy, final Scenario.Properties sprop)
 408                         throws MissedPropertyException, InvalidPropertyException,
 409                         MultiplyDefinedException {
 410                 if (sprop.getManager() == null) {
 411                         sprop.setManager(aStudy.getAuthor());
 412                 }
 413
 414                 Scenario scenario = new Scenario(sprop.setOwnerStudy(aStudy));
 415                 if (sprop.getBaseStep() != null) {
 416                         copyContentsUpTo(scenario, sprop.getBaseStep());
 417                 }
 418                 Scenario previous = sprop.getInsertAfter();
 419
 420                 if (previous == null) {
 421                         aStudy.getScenariiList().add(scenario);
 422                 } else {
 423                         aStudy.getScenariiList().add(
 424                                         aStudy.getScenariiList().indexOf(previous) + 1, scenario);
 425                 }
 426                 getStudyDAO().update(aStudy); // No need to update the Lucene index
 427                 getScenarioDAO().create(scenario); // Must be done after updating this study because of the back reference to the study
 428                 if (sprop.getBaseStep() != null) {
 429                         // No need to update the Knowledge Element index as Knowledge Elements are not copied
 430                         getProjectElementService().refresh(scenario); // Because saving the scenario changes the hashcode of copied Publications
 431                 }
 432                 KnowledgeElementType ucase = getKnowledgeElementTypeService()
 433                                 .selectType("usecase");
 434                 KnowledgeElement.Properties kprop = new KnowledgeElement.Properties();
 435                 User admin = getUserService().selectUser(1); // First user created when creating the database
 436                 kprop.setType(ucase).setTitle(aStudy.getTitle()).setValue(
 437                                 scenario.getTitle()).setAuthor(admin); // Internal Knowledge Element required by the validation process of
 438                 // knowledges
 439                 addKnowledgeElement(scenario, kprop);
 440                 return scenario;
 441         }
 442
 443         /**
 444          * Remove a knowledge element from a scenario.
 445          *
 446          * @param scenario
 447          *            the scenario
 448          * @param kelm
 449          *            the knowledge element to remove
 450          * @return true if removal succeeded
 451          */
 452         public boolean removeKnowledgeElement(final Scenario scenario,
 453                         final KnowledgeElement kelm) {
 454                 KnowledgeElement torem = scenario.getKnowledgeElement(kelm.getIndex());
 455                 if (torem == null) {
 456                         return false;
 457                 }
 458                 boolean done = scenario.getKnowledgeElements().remove(torem);
 459                 if (done) {
 460                         // Update of my transient data
 461                         // RKV: These transient data are not used indeed.
 462                         // RKV: List<KnowledgeElement> kelms = scenario.getKnowledgeByType().get(
 463                         // RKV: kelm.getType().getIndex());
 464                         // RKV: kelms.remove(torem);
 465                         if (scenario.getKnowledgeElementsList() != null) {
 466                                 scenario.getKnowledgeElementsList().remove(torem);
 467                         }
 468                         getScenarioDAO().update(scenario);
 469                         // TODO: If the owner study is not private, remove the knowledge from the Lucene index
 470                         return true;
 471                 } else {
 472                         return false;
 473                 }
 474         }
 475
 476         /**
 477          * Get the knowledgeElementDAO.
 478          *
 479          * @return the knowledgeElementDAO
 480          */
 481         public KnowledgeElementDAO getKnowledgeElementDAO() {
 482                 return _knowledgeElementDAO;
 483         }
 484
 485         /**
 486          * Set the knowledgeElementDAO.
 487          *
 488          * @param knowledgeElementDAO
 489          *            the knowledgeElementDAO to set
 490          */
 491         public void setKnowledgeElementDAO(final KnowledgeElementDAO knowledgeElementDAO) {
 492                 _knowledgeElementDAO = knowledgeElementDAO;
 493         }
 494
 495         /**
 496          * Get the indexService.
 497          *
 498          * @return the indexService
 499          */
 500         public IndexService getIndexService() {
 501                 return _indexService;
 502         }
 503
 504         /**
 505          * Set the indexService.
 506          *
 507          * @param indexService
 508          *            the indexService to set
 509          */
 510         public void setIndexService(final IndexService indexService) {
 511                 _indexService = indexService;
 512         }
 513
 514         /**
 515          * Get the scenarioDAO.
 516          *
 517          * @return the scenarioDAO
 518          */
 519         public ScenarioDAO getScenarioDAO() {
 520                 return _scenarioDAO;
 521         }
 522
 523         /**
 524          * Set the scenarioDAO.
 525          *
 526          * @param scenarioDAO
 527          *            the scenarioDAO to set
 528          */
 529         public void setScenarioDAO(final ScenarioDAO scenarioDAO) {
 530                 _scenarioDAO = scenarioDAO;
 531         }
 532
 533         /**
 534          * Get the studyDAO.
 535          *
 536          * @return the studyDAO
 537          */
 538         public StudyDAO getStudyDAO() {
 539                 return _studyDAO;
 540         }
 541
 542         /**
 543          * Set the studyDAO.
 544          *
 545          * @param studyDAO
 546          *            the studyDAO to set
 547          */
 548         public void setStudyDAO(final StudyDAO studyDAO) {
 549                 _studyDAO = studyDAO;
 550         }
 551
 552         /**
 553          * Get the knowledgeElementTypeService.
 554          *
 555          * @return the knowledgeElementTypeService
 556          */
 557         public KnowledgeElementTypeService getKnowledgeElementTypeService() {
 558                 return _knowledgeElementTypeService;
 559         }
 560
 561         /**
 562          * Set the knowledgeElementTypeService.
 563          *
 564          * @param knowledgeElementTypeService
 565          *            the knowledgeElementTypeService to set
 566          */
 567         public void setKnowledgeElementTypeService(
 568                         final KnowledgeElementTypeService knowledgeElementTypeService) {
 569                 _knowledgeElementTypeService = knowledgeElementTypeService;
 570         }
 571
 572         /**
 573          * Get the studyService.
 574          *
 575          * @return the studyService
 576          */
 577         public StudyService getStudyService() {
 578                 return _studyService;
 579         }
 580
 581         /**
 582          * Set the studyService.
 583          *
 584          * @param studyService
 585          *            the studyService to set
 586          */
 587         public void setStudyService(final StudyService studyService) {
 588                 _studyService = studyService;
 589         }
 590
 591         /**
 592          * Get the userService.
 593          *
 594          * @return the userService
 595          */
 596         public UserService getUserService() {
 597                 return _userService;
 598         }
 599
 600         /**
 601          * Set the userService.
 602          *
 603          * @param userService
 604          *            the userService to set
 605          */
 606         public void setUserService(final UserService userService) {
 607                 _userService = userService;
 608         }
 609
 610         /**
 611          * Get the userDAO.
 612          *
 613          * @return the userDAO
 614          */
 615         public UserDAO getUserDAO() {
 616                 return _userDAO;
 617         }
 618
 619         /**
 620          * Set the userDAO.
 621          *
 622          * @param userDAO
 623          *            the userDAO to set
 624          */
 625         public void setUserDAO(final UserDAO userDAO) {
 626                 _userDAO = userDAO;
 627         }
 628
 629         /**
 630          * Get the knowledgeElementTypeDAO.
 631          *
 632          * @return the knowledgeElementTypeDAO
 633          */
 634         public KnowledgeElementTypeDAO getKnowledgeElementTypeDAO() {
 635                 return _knowledgeElementTypeDAO;
 636         }
 637
 638         /**
 639          * Set the knowledgeElementTypeDAO.
 640          *
 641          * @param knowledgeElementTypeDAO
 642          *            the knowledgeElementTypeDAO to set
 643          */
 644         public void setKnowledgeElementTypeDAO(
 645                         final KnowledgeElementTypeDAO knowledgeElementTypeDAO) {
 646                 _knowledgeElementTypeDAO = knowledgeElementTypeDAO;
 647         }
 648
 649         /**
 650          * Get the simulationContextService.
 651          *
 652          * @return the simulationContextService
 653          */
 654         public SimulationContextService getSimulationContextService() {
 655                 return _simulationContextService;
 656         }
 657
 658         /**
 659          * Set the simulationContextService.
 660          *
 661          * @param simulationContextService
 662          *            the simulationContextService to set
 663          */
 664         public void setSimulationContextService(
 665                         final SimulationContextService simulationContextService) {
 666                 _simulationContextService = simulationContextService;
 667         }
 668
 669 }