]> SALOME platform Git repositories - tools/siman.git/blob - Workspace/Siman-Common/src/org/splat/service/ScenarioServiceImpl.java
Salome HOME
Fix: document format always has been taken from the previous version of the document...
[tools/siman.git] / 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.Date;
16 import java.util.HashMap;
17 import java.util.Iterator;
18 import java.util.List;
19 import java.util.Map;
20 import java.util.Set;
21
22 import org.hibernate.criterion.Order;
23 import org.hibernate.criterion.Restrictions;
24 import org.splat.common.properties.MessageKeyEnum;
25 import org.splat.dal.bo.kernel.Relation;
26 import org.splat.dal.bo.kernel.Role;
27 import org.splat.dal.bo.kernel.User;
28 import org.splat.dal.bo.som.ConvertsRelation;
29 import org.splat.dal.bo.som.Document;
30 import org.splat.dal.bo.som.DocumentType;
31 import org.splat.dal.bo.som.File;
32 import org.splat.dal.bo.som.KnowledgeElement;
33 import org.splat.dal.bo.som.KnowledgeElementType;
34 import org.splat.dal.bo.som.ProgressState;
35 import org.splat.dal.bo.som.Publication;
36 import org.splat.dal.bo.som.Scenario;
37 import org.splat.dal.bo.som.SimulationContext;
38 import org.splat.dal.bo.som.Study;
39 import org.splat.dal.bo.som.UsedByRelation;
40 import org.splat.dal.bo.som.UsesRelation;
41 import org.splat.dal.dao.kernel.RoleDAO;
42 import org.splat.dal.dao.kernel.UserDAO;
43 import org.splat.dal.dao.som.KnowledgeElementDAO;
44 import org.splat.dal.dao.som.KnowledgeElementTypeDAO;
45 import org.splat.dal.dao.som.ScenarioDAO;
46 import org.splat.dal.dao.som.StudyDAO;
47 import org.splat.kernel.InvalidPropertyException;
48 import org.splat.kernel.MismatchException;
49 import org.splat.kernel.MissedPropertyException;
50 import org.splat.kernel.MultiplyDefinedException;
51 import org.splat.kernel.NotApplicableException;
52 import org.splat.log.AppLogger;
53 import org.splat.service.dto.DocumentDTO;
54 import org.splat.service.dto.FileDTO;
55 import org.splat.service.dto.StepDTO;
56 import org.splat.service.technical.IndexService;
57 import org.splat.service.technical.ProjectSettingsService;
58 import org.splat.som.Step;
59 import org.splat.util.BeanHelper;
60 import org.springframework.transaction.annotation.Transactional;
61
62 /**
63  * Scenario service implementation.
64  * 
65  * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
66  */
67 public class ScenarioServiceImpl implements ScenarioService {
68
69         /**
70          * The logger for the service.
71          */
72         public final static AppLogger LOG = AppLogger
73                         .getLogger(ScenarioServiceImpl.class);
74
75         /**
76          * Injected index service.
77          */
78         private IndexService _indexService;
79         /**
80          * Injected step service.
81          */
82         private StepService _stepService;
83         /**
84          * Injected study service.
85          */
86         private StudyService _studyService;
87         /**
88          * Injected publication service.
89          */
90         private PublicationService _publicationService;
91         /**
92          * Injected project element service.
93          */
94         private ProjectElementService _projectElementService;
95         /**
96          * Injected knowledge element DAO.
97          */
98         private KnowledgeElementDAO _knowledgeElementDAO;
99         /**
100          * Injected scenario DAO.
101          */
102         private ScenarioDAO _scenarioDAO;
103
104         /**
105          * Injected study DAO.
106          */
107         private StudyDAO _studyDAO;
108
109         /**
110          * Injected knowledge element service.
111          */
112         private KnowledgeElementTypeService _knowledgeElementTypeService;
113
114         /**
115          * Injected user service.
116          */
117         private UserService _userService;
118
119         /**
120          * Injected user DAO.
121          */
122         private UserDAO _userDAO;
123
124         /**
125          * Injected role DAO.
126          */
127         private RoleDAO _roleDAO;
128
129         /**
130          * Injected knowledge element type DAO.
131          */
132         private KnowledgeElementTypeDAO _knowledgeElementTypeDAO;
133
134         /**
135          * Injected simulation context service.
136          */
137         private SimulationContextService _simulationContextService;
138
139         /**
140          * Injected project service.
141          */
142         private ProjectSettingsService _projectSettings;
143
144         /**
145          * Injected document type service.
146          */
147         private DocumentTypeService _documentTypeService;
148
149         /**
150          * Get the projectElementService.
151          * 
152          * @return the projectElementService
153          */
154         public ProjectElementService getProjectElementService() {
155                 return _projectElementService;
156         }
157
158         /**
159          * Set the projectElementService.
160          * 
161          * @param projectElementService
162          *            the projectElementService to set
163          */
164         public void setProjectElementService(
165                         final ProjectElementService projectElementService) {
166                 _projectElementService = projectElementService;
167         }
168
169         /**
170          * Get the publicationService.
171          * 
172          * @return the publicationService
173          */
174         public PublicationService getPublicationService() {
175                 return _publicationService;
176         }
177
178         /**
179          * Set the publicationService.
180          * 
181          * @param publicationService
182          *            the publicationService to set
183          */
184         public void setPublicationService(
185                         final PublicationService publicationService) {
186                 _publicationService = publicationService;
187         }
188
189         /**
190          * Get the stepService.
191          * 
192          * @return the stepService
193          */
194         public StepService getStepService() {
195                 return _stepService;
196         }
197
198         /**
199          * Set the stepService.
200          * 
201          * @param stepService
202          *            the stepService to set
203          */
204         public void setStepService(final StepService stepService) {
205                 _stepService = stepService;
206         }
207
208         /**
209          * {@inheritDoc}
210          * 
211          * @see org.splat.service.ScenarioService#getScenarioInfo(long)
212          */
213         @Transactional(readOnly = true)
214         public List<StepDTO> getScenarioInfo(final long scenarioId) {
215                 List<StepDTO> res = new ArrayList<StepDTO>();
216                 // Get the scenario from the database by id
217                 Scenario scen = getScenarioDAO().get(scenarioId);
218                 if (LOG.isDebugEnabled()) {
219                         LOG.debug("Scenario[" + scenarioId + "]: Number of publications: "
220                                         + scen.getDocums().size());
221                 }
222                 // Get activities of the scenario
223                 Step[] steps = getProjectElementService().getSteps(scen);
224                 StepDTO stepDTO;
225                 DocumentDTO docDTO;
226                 String docType, fileFormat;
227                 String processing;
228                 boolean doImport;
229                 // For each activity create a step DTO and add it to the result list
230                 for (Step step : steps) {
231                         stepDTO = BeanHelper.copyBean(step.getStep(), StepDTO.class);
232                         res.add(stepDTO);
233                         if (LOG.isDebugEnabled()) {
234                                 LOG.debug("Step[" + stepDTO.getNumber()
235                                                 + "]: Number of documents: "
236                                                 + step.getDocuments().size());
237                         }
238                         // For each publication of the activity create a document DTO.
239                         // Each file is considered as a source file.
240                         for (Publication tag : step.getDocuments()) {
241                                 docDTO = stepDTO.addDoc(tag.value().getIndex(), tag.value()
242                                                 .getTitle());
243                                 char aState = tag.getIsnew();
244                                 docType = tag.value().getType().getName();
245                                 // For each file of the document create a file DTO
246                                 // Process source file of the document
247                                 fileFormat = tag.value().getFile().getFormat();
248                                 doImport = getProjectSettings().doImport(docType, fileFormat);
249                                 if (doImport && (!tag.isOutdated())) {
250                                         processing = "file-import";
251                                 } else {
252                                         processing = "file-download";
253                                 }
254                                 File aFile = tag.value().getFile();
255                                 docDTO.addFile(aFile.getIndex(), aFile.getRelativePath(),
256                                                 aState, processing, false);
257                                 // Process all exported files
258                                 for (Relation rel : tag.value().getRelations(
259                                                 ConvertsRelation.class)) {
260                                         aFile = ((ConvertsRelation) rel).getTo();
261                                         fileFormat = aFile.getFormat();
262                                         doImport = getProjectSettings().doImport(docType,
263                                                         fileFormat);
264                                         if (doImport && (!tag.isOutdated())) {
265                                                 processing = "file-import";
266                                         } else {
267                                                 processing = "file-download";
268                                         }
269                                         docDTO.addFile(aFile.getIndex(), aFile.getRelativePath(),
270                                                         aState, processing, false);
271                                 }
272                         }
273                 }
274                 return res;
275         }
276
277         /**
278          * Create a new study with one scenario and "product" simulation context.
279          * 
280          * @param sprop
281          *            the study properties
282          * @param oprop
283          *            the scenario properties
284          * @param cprop
285          *            the "product" simulation context properties
286          * @return the created study
287          * @throws MissedPropertyException
288          *             if a mandatory property is missed
289          * @throws InvalidPropertyException
290          *             if a property is invalid
291          * @throws MultiplyDefinedException
292          *             if some property occurs several times
293          */
294         @Transactional
295         public Study createStudy(final Study.Properties sprop,
296                         final Scenario.Properties oprop,
297                         final SimulationContext.Properties cprop)
298                         throws MissedPropertyException, InvalidPropertyException,
299                         MultiplyDefinedException {
300                 Study study = getStudyService().createStudy(sprop);
301                 addScenario(study, oprop);
302                 if (cprop.getIndex() == 0) { // Input of new project context
303                         cprop.setType(getSimulationContextService().selectType("product"))
304                                         .setValue(cprop.getValue());
305                         getStudyService().addProjectContext(study, cprop);
306                 } else { // Selection of existing project context
307                         SimulationContext context = getSimulationContextService()
308                                         .selectSimulationContext(cprop.getIndex());
309                         getStudyService().addProjectContext(study, context);
310                 }
311                 return study;
312         }
313
314         /**
315          * {@inheritDoc}
316          * 
317          * @see org.splat.service.ScenarioService#addKnowledgeElement(org.splat.dal.bo.som.Scenario,
318          *      org.splat.dal.bo.som.KnowledgeElement.Properties)
319          */
320         @Transactional
321         public KnowledgeElement addKnowledgeElement(final Scenario aScenarioDTO,
322                         final KnowledgeElement.Properties kprop)
323                         throws MissedPropertyException, InvalidPropertyException,
324                         MultiplyDefinedException {
325                 KnowledgeElement kelm = null;
326                 try {
327                         long aScenarioId = aScenarioDTO.getIndex();
328                         if (LOG.isDebugEnabled()) {
329                                 LOG.debug("Add a knowledge element to the scenario #"
330                                                 + aScenarioId);
331                         }
332                         // Get the persistent scenario.
333                         Scenario aScenario = getScenarioDAO().get(aScenarioId);
334                         // Get persistent objects for creating a new knowledge.
335                         // TODO: Actions must use DTO instead of persistent objects.
336                         getUserDAO().merge(kprop.getAuthor());
337                         getKnowledgeElementTypeDAO().merge(kprop.getType());
338                         // Create a transient knowledge element related to the given scenario.
339                         kelm = new KnowledgeElement(kprop.setOwnerScenario(aScenario));
340                         // Save the new knowledge in the database.
341                         getKnowledgeElementDAO().create(kelm);
342                         // Update scenario transient data.
343                         if (kelm.getType().equals("usecase")) {
344                                 aScenarioDTO.setUcase(kelm);
345                         } else if (aScenarioDTO.getKnowledgeElementsList() != null) { // If null, knowl will be initialized when needed
346                                 aScenarioDTO.getKnowledgeElementsList().add(kelm);
347                         }
348
349                         // Load the workflow for the parent study to take into account
350                         // all study actors durng reindexing.
351                         getStudyService().loadWorkflow(aScenario.getOwnerStudy());
352
353                         // Update the lucene index of knowledge elements.
354                         getIndexService().add(kelm);
355                         if (LOG.isDebugEnabled()) {
356                                 LOG.debug("A knowledge element #" + kelm.getIndex()
357                                                 + " is added to the scenario #" + aScenario.getIndex());
358                         }
359                 } catch (IOException error) {
360                         LOG.error("Unable to index the knowedge element '"
361                                         + kelm.getIndex() + "', reason:", error);
362                         kelm = null;
363                 }
364
365                 return kelm;
366         }
367
368         /**
369          * Update the scenario in the database.
370          * 
371          * @param aScenario
372          *            the scenario to update
373          * @return true if updating succeeded
374          */
375         @Transactional
376         private boolean update(final Scenario aScenario) {
377                 boolean isOk = false;
378                 try {
379                         getScenarioDAO().update(aScenario); // Update of relational base
380                         isOk = true;
381                 } catch (Exception error) {
382                         LOG.error("Unable to re-index the knowledge element '"
383                                         + aScenario.getIndex() + "', reason:", error);
384                 }
385                 return isOk;
386         }
387
388         /**
389          * {@inheritDoc}
390          * 
391          * @see org.splat.service.ScenarioService#checkin(long, long, java.util.List)
392          */
393         @Transactional
394         public void checkin(final long scenId, final long userId,
395                         final List<StepDTO> scInfo) throws InvalidPropertyException,
396                         MissedPropertyException, MultiplyDefinedException,
397                         MismatchException, IOException, NotApplicableException {
398                 // Get the scenario from the database by id
399                 Scenario aScenario = getScenarioDAO().get(scenId);
400                 // Get the user who perform this check-in operation
401                 User aUser = getUserService().selectUser(userId);
402                 // Get activities of the scenario
403                 Step[] steps = getProjectElementService().getSteps(aScenario);
404                 // Find result document types
405                 List<DocumentType> resTypes = getDocumentTypeService()
406                                 .selectResultTypes();
407
408                 // Keep newly created documents to create uses relations to results of a previous step.
409                 // For each processed existing document keep its new version
410                 Map<Document, Document> newVersion = new HashMap<Document, Document>();
411                 // Created publications of new created versions of existing documents
412                 List<Publication> newVers = new ArrayList<Publication>();
413                 // The list of publications of new created documents not existing before the checkin
414                 List<Publication> newDocs = new ArrayList<Publication>();
415                 // For each step DTO
416                 DocumentType resType;
417                 Date aDate = new Date(); // The timestamp of the checkin operation
418                 for (StepDTO stepDTO : scInfo) {
419                         if (LOG.isDebugEnabled()) {
420                                 LOG.debug("Checkin the step:\n" + stepDTO);
421                         }
422                         // Find a result document type of the step
423                         int i = 0;
424                         resType = null;
425                         do {
426                                 if (resTypes.get(i).isResultOf(
427                                                 getProjectSettings().getStep(stepDTO.getNumber()))) {
428                                         resType = resTypes.get(i);
429                                 }
430                                 i++;
431                         } while ((resType == null) && (i < resTypes.size()));
432
433                         // Find the appropriate scenario step
434                         Step step = findStep(stepDTO, steps);
435
436                         // Process each document of the step
437                         for (DocumentDTO doc : stepDTO.getDocs()) {
438                                 checkinDoc(step, doc, aUser, resType, aDate, newVersion,
439                                                 newVers, newDocs);
440                         }
441                 }
442
443                 // Set uses/used relations
444                 updateRelationsAfterCheckin(aScenario, newVersion, newVers, newDocs);
445
446                 // Mark the scenario as checked in
447                 checkin(aScenario);
448         }
449
450         /**
451          * Updated uses/used relations after checkin operation:<BR>
452          * <ul>
453          * <li>For each new version copy uses relations from the previous version.</li>
454          * <li>Outdate documents which depend from the previous version and were not checked in during this operation.</li>
455          * <li>For each new document create uses relation to the last versions of results of the previous step.</li>
456          * </ul>
457          * 
458          * @param aScenario
459          *            the checked in scenario
460          * @param newVersion
461          *            the mapping of documents existed before the checkin to their new created versions
462          * @param newVers
463          *            the list of publications of new created versions of documents existed before the checkin
464          * @param newDocs
465          *            the list of publications of new created documents not existed before the checkin
466          */
467         private void updateRelationsAfterCheckin(final Scenario aScenario,
468                         final Map<Document, Document> newVersion,
469                         final List<Publication> newVers, final List<Publication> newDocs) {
470                 // For each new version copy uses relations from the previous version.
471                 for (Publication newVer : newVers) {
472                         // For each Uses relation of the previous version
473                         Document prevDoc = newVer.value().getPreviousVersion();// prevVersion.get(newVer);
474                         if (LOG.isDebugEnabled()) {
475                                 LOG.debug("Previous version for publication #"
476                                                 + newVer.getIndex() + " is found: " + prevDoc);
477                         }
478                         List<Relation> usesRelations = prevDoc
479                                         .getRelations(UsesRelation.class);
480                         for (Relation rel : usesRelations) {
481                                 // If used document has been also versioned then refer to its new version.
482                                 Document usedDoc = ((UsesRelation) rel).getTo();
483                                 if (newVersion.containsKey(usedDoc)) {
484                                         usedDoc = newVersion.get(usedDoc);
485                                 }
486                                 // Build the appropriate relation for the new version.
487                                 newVer.addDependency(usedDoc);
488                         }
489                         // Outdate documents which depend from the previous version and
490                         // were not checked in during this operation.
491                         // 1. Get all usedBy relations of the previous document version
492                         for (Relation rel : prevDoc.getRelations(UsedByRelation.class)) {
493                                 Document using = ((UsedByRelation) rel).getTo();
494                                 // Check that not checked in dependent documents became outdated
495                                 Publication usingPub = aScenario.getPublication(using);
496                                 if (usingPub != null) { // if the document using the old version is still published
497                                         usingPub.setIsnew('O');
498                                 }
499                         }
500                 }
501
502                 // For each new document create uses relation to the last versions of
503                 // results of the previous step.
504                 for (Publication newPub : newDocs) {
505                         // Find used document type according to the configuration.
506                         Set<DocumentType> usedTypes = newPub.value().getType()
507                                         .getDefaultUses();
508                         // Find documents of used type in the previous study step.
509                         for (Publication pub : aScenario.getDocums()) {
510                                 if ((pub.getStep().getNumber() <= newPub.getStep().getNumber())
511                                                 && (!pub.isOutdated())
512                                                 && usedTypes.contains(pub.value().getType())) {
513                                         // Create uses relation from the new document
514                                         // to the found document in the previous step.
515                                         newPub.addDependency(pub);
516                                 }
517                         }
518                 }
519         }
520
521         /**
522          * Pure checkin of the document without creation of uses/usedBy relations. For an existing document a new version is created. New
523          * documents become published in the given step of the appropriate scenario. The appropriate uploaded file is attached to the created
524          * document and the document is published in the scenario. The publication of the old version is removed from the scenario.
525          * 
526          * @param step
527          *            the destination scenario step
528          * @param doc
529          *            the DTO of the document to checkin
530          * @param aUser
531          *            the user who performs checkin
532          * @param resType
533          *            the result document type of the given step
534          * @param aDate
535          *            timestamp of the checkin operation
536          * @param newVersion
537          *            the mapping of existing documents to their new created versions
538          * @param newVers
539          *            the list of publications of new created versions of existing documents
540          * @param newDocs
541          *            the list of publications of new created documents not existing before the checkin
542          * @throws InvalidPropertyException
543          *             if the scenario hasn't some of given steps or documents
544          * @throws IOException
545          *             if a file can't be moved into the vault
546          * @throws MismatchException
547          *             if version creation in some of steps is failed
548          * @throws MissedPropertyException
549          *             if some mandatory property is missed when new document or new document version is created
550          * @throws MultiplyDefinedException
551          *             if some property is defined several times when new document or new document version is created
552          * @throws NotApplicableException
553          *             if failed saving of a new publication with a given state
554          */
555         private void checkinDoc(final Step step, final DocumentDTO doc,
556                         final User aUser, final DocumentType resType, final Date aDate,
557                         final Map<Document, Document> newVersion,
558                         final List<Publication> newVers, final List<Publication> newDocs)
559                         throws InvalidPropertyException, MismatchException,
560                         MissedPropertyException, MultiplyDefinedException, IOException,
561                         NotApplicableException {
562                 if (doc.getFiles().size() > 0) {
563                         Document.Properties dprop = new Document.Properties();
564                         // NOTE: Process only the first attached file for each document
565                         FileDTO file = doc.getFiles().get(0);
566
567                         // Get document title as the file name
568                         java.io.File upfile = new java.io.File(file.getPath());
569                         String fileFormat = upfile.getName().substring(
570                                         upfile.getName().lastIndexOf('.') + 1);
571
572                         // Create a new document or a new version of the document
573                         dprop.setAuthor(aUser).setDate(aDate).setFormat(fileFormat);
574                         Publication pub, newPub;
575
576                         if (doc.getId() > 0) {
577                                 // If the document already exists then create a new version of it
578                                 // Find the document publication
579                                 pub = step.getDocument(doc.getId());
580                                 if (pub == null) {
581                                         throw new InvalidPropertyException(
582                                                         MessageKeyEnum.SCN_000002.toString(), doc.getId());
583                                 }
584                                 if (pub.value() == null) {
585                                         throw new MismatchException(MessageKeyEnum.SCN_000002
586                                                         .toString(), doc.getId());
587                                 }
588                                 if (LOG.isDebugEnabled()) {
589                                         LOG.debug("Old format: " + pub.value().getFormat()
590                                                         + " => New format: " + fileFormat);
591                                 }
592                                 newPub = getStepService().versionDocument(step, pub, dprop);
593                                 if (LOG.isDebugEnabled()) {
594                                         LOG.debug("Created document type: "
595                                                         + newPub.value().getType().getName() + ", format: "
596                                                         + newPub.value().getFormat());
597                                 }
598                                 // Remeber the link from the old document to the new document version
599                                 newVersion.put(pub.value(), newPub.value());
600                                 // Remember the new version publication
601                                 newVers.add(newPub);
602                         } else {
603
604                                 // Otherwise create a new document of the result type
605                                 // If result type is not found try to get type by file extension
606                                 if (resType == null) {
607                                         dprop.setType(getProjectSettings().getDefaultDocumentType(
608                                                         step.getStep(), fileFormat));
609                                 } else {
610                                         dprop.setType(resType);
611                                 }
612                                 // New document title generation as <document type name>_N
613                                 String docname = dprop.getType().getName();
614                                 int i = 1;
615                                 for (Publication scenPub : step.getOwner().getDocums()) {
616                                         if (scenPub.value().getTitle().startsWith(docname)) {
617                                                 i++;
618                                         }
619                                 }
620                                 docname += "_" + i; // The generated new document title
621
622                                 dprop.setDescription("Checked in").setName(docname);
623                                 newPub = getStepService().createDocument(step, dprop);
624
625                                 // Remeber the new document
626                                 newDocs.add(newPub);
627                         }
628
629                         // Attach the file to the created document
630                         java.io.File updir = newPub.getSourceFile().asFile();
631                         if (LOG.isDebugEnabled()) {
632                                 LOG.debug("Moving \"" + upfile.getName() + "\" to \""
633                                                 + updir.getPath() + "\".");
634                         }
635                         if (updir.exists()) {
636                                 if (updir.delete()) {
637                                         LOG.info(MessageKeyEnum.SCN_000003.toString(), updir
638                                                         .getAbsoluteFile(), step.getOwner().getIndex());
639                                 } else {
640                                         throw new IOException(
641                                                         "Can't delete the existing destination file to move file from "
642                                                                         + file.getPath() + " to "
643                                                                         + updir.getAbsolutePath());
644                                 }
645                         }
646                         if (upfile.renameTo(updir)) {
647                                 // Save the new publication in the scenario.
648                                 // The old publication is removed from the scenario here.
649                                 getPublicationService().saveAs(newPub, ProgressState.inWORK); // May throw FileNotFound if rename was not done
650                         } else {
651                                 throw new IOException("Can't move file from " + file.getPath()
652                                                 + " to " + updir.getAbsolutePath());
653                         }
654                 }
655         }
656
657         /**
658          * Find appropriate step in the array of scenario steps according to the given step DTO.
659          * 
660          * @param stepDTO
661          *            the stepDTO
662          * @param steps
663          *            scenario steps
664          * @return appropriate scenario step
665          * @throws InvalidPropertyException
666          *             if appropriate step is not found
667          */
668         private Step findStep(final StepDTO stepDTO, final Step[] steps)
669                         throws InvalidPropertyException {
670                 int i = 0;
671                 Step step = null;
672                 do {
673                         if (steps[i].getNumber() == stepDTO.getNumber()) {
674                                 step = steps[i];
675                         }
676                         i++;
677                 } while ((step == null) && (i < steps.length));
678
679                 if (step == null) {
680                         throw new InvalidPropertyException(MessageKeyEnum.SCN_000001
681                                         .toString(), stepDTO.getNumber());
682                 }
683                 return step;
684         }
685
686         /**
687          * {@inheritDoc}
688          * 
689          * @see org.splat.service.ScenarioService#checkin(long)
690          */
691         @Transactional
692         public void checkin(final long scenarioId) throws InvalidPropertyException {
693                 Scenario aScenario = getScenarioDAO().get(scenarioId);
694                 if (aScenario == null) {
695                         // Scenario not found
696                         throw new InvalidPropertyException(MessageKeyEnum.SCN_000006
697                                         .toString(), scenarioId);
698                 }
699                 checkin(aScenario);
700         }
701
702         /**
703          * Mark the scenario as checked in.
704          * 
705          * @param aScenario
706          *            the scenario to check in.
707          */
708         private void checkin(final Scenario aScenario) {
709                 aScenario.setUser(null);
710                 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
711                 // getScenarioDAO().update(aScenario);
712         }
713
714         /**
715          * {@inheritDoc}
716          * 
717          * @see org.splat.service.ScenarioService#checkout(org.splat.dal.bo.som.Scenario, org.splat.dal.bo.kernel.User)
718          */
719         public boolean checkout(final Scenario aScenario, final User user) {
720                 boolean res = getStudyService().isStaffedBy(aScenario.getOwnerStudy(),
721                                 user);
722                 if (res) {
723                         aScenario.setUser(user);
724                         aScenario.setLastModificationDate(Calendar.getInstance().getTime());
725                         // RKV: getScenarioDAO().update(aScenario);
726                 }
727                 return res;
728         }
729
730         /**
731          * Mark the given scenario as checked out by the given user.
732          * 
733          * @param scenarioId
734          *            the scenario id
735          * @param userId
736          *            the id of the user performing the check out
737          * @throws InvalidPropertyException
738          *             if the user or the scenario is not found in the database
739          * @throws NotApplicableException
740          *             if the given user can not check out the scenario
741          */
742         @Transactional
743         public void checkout(final long scenarioId, final long userId)
744                         throws InvalidPropertyException, NotApplicableException {
745                 User aUser = getUserService().selectUser(userId);
746                 if (aUser == null) {
747                         // User not found
748                         throw new InvalidPropertyException(MessageKeyEnum.USR_000001
749                                         .toString(), userId);
750                 }
751                 Scenario aScenario = getScenarioDAO().get(scenarioId);
752                 if (aScenario == null) {
753                         // Scenario not found
754                         throw new InvalidPropertyException(MessageKeyEnum.SCN_000006
755                                         .toString(), scenarioId);
756                 }
757                 boolean res = getStudyService().isStaffedBy(aScenario.getOwnerStudy(),
758                                 aUser);
759                 if (res) {
760                         if (aScenario.isCheckedout()
761                                         && (!aScenario.getUser().getUsername().equals(
762                                                         aUser.getUsername()))) {
763                                 throw new NotApplicableException(MessageKeyEnum.SCN_000008
764                                                 .toString(), scenarioId, aScenario.getUser()
765                                                 .getUsername());
766                         }
767                         aScenario.setUser(aUser);
768                         aScenario.setLastModificationDate(Calendar.getInstance().getTime());
769                 } else {
770                         // User doesn't participate in the scenario
771                         throw new NotApplicableException(MessageKeyEnum.SCN_000007
772                                         .toString(), aUser.getUsername(), scenarioId);
773                 }
774         }
775
776         /**
777          * {@inheritDoc}
778          * 
779          * @see org.splat.service.ScenarioService#copyContentsUpTo(org.splat.dal.bo.som.Scenario, org.splat.som.Step)
780          */
781         public void copyContentsUpTo(final Scenario scenario, final Step lastep) {
782                 Scenario base = (Scenario) lastep.getOwner();
783                 Step[] from = getProjectElementService().getSteps(base);
784                 Step[] to = getProjectElementService().getSteps(scenario);
785                 for (int i = 0; i < from.length; i++) {
786                         Step step = from[i];
787                         if (step.getNumber() > lastep.getNumber()) {
788                                 break;
789                         }
790
791                         List<Publication> docs = step.getAllDocuments();
792                         for (Iterator<Publication> j = docs.iterator(); j.hasNext();) {
793                                 Publication doc = getPublicationService().copy(j.next(),
794                                                 scenario); // Creation of a new reference to the document
795                                 // Database.getSession().save(doc); Publications MUST be saved later through cascading when saving the scenario
796                                 getStepService().add(to[i], doc);
797                         }
798                         List<SimulationContext> ctex = step.getAllSimulationContexts();
799                         for (Iterator<SimulationContext> j = ctex.iterator(); j.hasNext();) {
800                                 getStepService().addSimulationContext(to[i], j.next());
801                         }
802                 }
803         }
804
805         /**
806          * {@inheritDoc}
807          * 
808          * @see org.splat.service.ScenarioService#isEmpty(org.splat.dal.bo.som.Scenario)
809          */
810         public boolean isEmpty(final Scenario scenario) {
811                 Step[] mystep = getProjectElementService().getSteps(scenario);
812                 boolean isEmp = true;
813                 for (int i = 0; i < mystep.length; i++) {
814                         if (mystep[i].isStarted()) {
815                                 isEmp = false;
816                                 break;
817                         }
818                 }
819                 return isEmp;
820         }
821
822         /**
823          * @param scenario
824          * @return
825          */
826         public boolean isFinished(final Scenario scenario) {
827                 Step[] mystep = getProjectElementService().getSteps(scenario);
828                 boolean notempty = false; // If this is empty, this is not finished
829                 for (int i = 0; i < mystep.length; i++) {
830                         if (!mystep[i].isStarted()) {
831                                 continue;
832                         }
833                         if (!mystep[i].isFinished()) {
834                                 return false;
835                         }
836                         notempty = true;
837                 }
838                 return notempty;
839         }
840
841         /**
842          * {@inheritDoc}
843          * 
844          * @see org.splat.service.StudyService#addScenario(org.splat.dal.bo.som.Study, org.splat.dal.bo.som.Scenario.Properties)
845          */
846         @Transactional
847         public Scenario addScenario(final Study aStudy,
848                         final Scenario.Properties sprop) throws MissedPropertyException,
849                         InvalidPropertyException, MultiplyDefinedException {
850                 if (sprop.getManager() == null) {
851                         sprop.setManager(aStudy.getAuthor());
852                 }
853
854                 Scenario scenario = new Scenario(sprop.setOwnerStudy(aStudy));
855                 if (sprop.getBaseStep() != null) {
856                         copyContentsUpTo(scenario, sprop.getBaseStep());
857                 }
858                 Scenario previous = sprop.getInsertAfter();
859
860                 if (previous == null) {
861                         aStudy.getScenariiList().add(scenario);
862                 } else {
863                         aStudy.getScenariiList().add(
864                                         aStudy.getScenariiList().indexOf(previous) + 1, scenario);
865                 }
866                 getStudyDAO().update(aStudy); // No need to update the Lucene index
867                 getScenarioDAO().create(scenario); // Must be done after updating this study because of the back reference to the study
868                 if (sprop.getBaseStep() != null) {
869                         // No need to update the Knowledge Element index as Knowledge Elements are not copied
870                         getProjectElementService().refresh(scenario); // Because saving the scenario changes the hashcode of copied Publications
871                 }
872                 KnowledgeElementType ucase = getKnowledgeElementTypeService()
873                                 .selectType("usecase");
874                 KnowledgeElement.Properties kprop = new KnowledgeElement.Properties();
875                 // TODO: Get appropriate user by its role: UserService.getAdmin();
876                 // User admin = getUserService().selectUser(1); // First user created when creating the database
877                 Role adminRole = getRoleDAO().getFilteredList(
878                                 Restrictions.like("role", "%sysadmin%")).get(0);
879                 User admin = getUserDAO().getFilteredList(
880                                 Restrictions.eq("role", adminRole), Order.asc("rid")).get(0); // First sysadmin in the database
881
882                 kprop.setType(ucase).setTitle(aStudy.getTitle()).setValue(
883                                 scenario.getTitle()).setAuthor(admin); // Internal Knowledge Element required by the validation process of
884                 // knowledges
885                 addKnowledgeElement(scenario, kprop);
886                 return scenario;
887         }
888
889         /**
890          * Remove a knowledge element from a scenario.
891          * 
892          * @param scenario
893          *            the scenario
894          * @param kelm
895          *            the knowledge element to remove
896          * @return true if removal succeeded
897          */
898         @Transactional
899         public boolean removeKnowledgeElement(final Scenario scenario,
900                         final KnowledgeElement kelm) {
901                 KnowledgeElement torem = scenario.getKnowledgeElement(kelm.getIndex());
902                 boolean isOk = (torem != null);
903                 if (isOk) {
904                         isOk = scenario.getKnowledgeElements().remove(torem);
905                         if (isOk) {
906                                 getScenarioDAO().merge(scenario);
907                                 // Update of my transient data
908                                 // RKV: These transient data are not used indeed.
909                                 // RKV: List<KnowledgeElement> kelms = scenario.getKnowledgeByType().get(
910                                 // RKV: kelm.getType().getIndex());
911                                 // RKV: kelms.remove(torem);
912                                 if (scenario.getKnowledgeElementsList() != null) {
913                                         scenario.getKnowledgeElementsList().remove(torem);
914                                 }
915                                 // TODO: If the owner study is not private, remove the knowledge from the Lucene index
916                         }
917                 }
918                 return isOk;
919         }
920
921         /**
922          * Get the knowledgeElementDAO.
923          * 
924          * @return the knowledgeElementDAO
925          */
926         public KnowledgeElementDAO getKnowledgeElementDAO() {
927                 return _knowledgeElementDAO;
928         }
929
930         /**
931          * Set the knowledgeElementDAO.
932          * 
933          * @param knowledgeElementDAO
934          *            the knowledgeElementDAO to set
935          */
936         public void setKnowledgeElementDAO(
937                         final KnowledgeElementDAO knowledgeElementDAO) {
938                 _knowledgeElementDAO = knowledgeElementDAO;
939         }
940
941         /**
942          * Get the indexService.
943          * 
944          * @return the indexService
945          */
946         public IndexService getIndexService() {
947                 return _indexService;
948         }
949
950         /**
951          * Set the indexService.
952          * 
953          * @param indexService
954          *            the indexService to set
955          */
956         public void setIndexService(final IndexService indexService) {
957                 _indexService = indexService;
958         }
959
960         /**
961          * Get the scenarioDAO.
962          * 
963          * @return the scenarioDAO
964          */
965         public ScenarioDAO getScenarioDAO() {
966                 return _scenarioDAO;
967         }
968
969         /**
970          * Set the scenarioDAO.
971          * 
972          * @param scenarioDAO
973          *            the scenarioDAO to set
974          */
975         public void setScenarioDAO(final ScenarioDAO scenarioDAO) {
976                 _scenarioDAO = scenarioDAO;
977         }
978
979         /**
980          * Get the studyDAO.
981          * 
982          * @return the studyDAO
983          */
984         public StudyDAO getStudyDAO() {
985                 return _studyDAO;
986         }
987
988         /**
989          * Set the studyDAO.
990          * 
991          * @param studyDAO
992          *            the studyDAO to set
993          */
994         public void setStudyDAO(final StudyDAO studyDAO) {
995                 _studyDAO = studyDAO;
996         }
997
998         /**
999          * Get the knowledgeElementTypeService.
1000          * 
1001          * @return the knowledgeElementTypeService
1002          */
1003         public KnowledgeElementTypeService getKnowledgeElementTypeService() {
1004                 return _knowledgeElementTypeService;
1005         }
1006
1007         /**
1008          * Set the knowledgeElementTypeService.
1009          * 
1010          * @param knowledgeElementTypeService
1011          *            the knowledgeElementTypeService to set
1012          */
1013         public void setKnowledgeElementTypeService(
1014                         final KnowledgeElementTypeService knowledgeElementTypeService) {
1015                 _knowledgeElementTypeService = knowledgeElementTypeService;
1016         }
1017
1018         /**
1019          * Get the studyService.
1020          * 
1021          * @return the studyService
1022          */
1023         public StudyService getStudyService() {
1024                 return _studyService;
1025         }
1026
1027         /**
1028          * Set the studyService.
1029          * 
1030          * @param studyService
1031          *            the studyService to set
1032          */
1033         public void setStudyService(final StudyService studyService) {
1034                 _studyService = studyService;
1035         }
1036
1037         /**
1038          * Get the userService.
1039          * 
1040          * @return the userService
1041          */
1042         public UserService getUserService() {
1043                 return _userService;
1044         }
1045
1046         /**
1047          * Set the userService.
1048          * 
1049          * @param userService
1050          *            the userService to set
1051          */
1052         public void setUserService(final UserService userService) {
1053                 _userService = userService;
1054         }
1055
1056         /**
1057          * Get the userDAO.
1058          * 
1059          * @return the userDAO
1060          */
1061         public UserDAO getUserDAO() {
1062                 return _userDAO;
1063         }
1064
1065         /**
1066          * Set the userDAO.
1067          * 
1068          * @param userDAO
1069          *            the userDAO to set
1070          */
1071         public void setUserDAO(final UserDAO userDAO) {
1072                 _userDAO = userDAO;
1073         }
1074
1075         /**
1076          * Get the knowledgeElementTypeDAO.
1077          * 
1078          * @return the knowledgeElementTypeDAO
1079          */
1080         public KnowledgeElementTypeDAO getKnowledgeElementTypeDAO() {
1081                 return _knowledgeElementTypeDAO;
1082         }
1083
1084         /**
1085          * Set the knowledgeElementTypeDAO.
1086          * 
1087          * @param knowledgeElementTypeDAO
1088          *            the knowledgeElementTypeDAO to set
1089          */
1090         public void setKnowledgeElementTypeDAO(
1091                         final KnowledgeElementTypeDAO knowledgeElementTypeDAO) {
1092                 _knowledgeElementTypeDAO = knowledgeElementTypeDAO;
1093         }
1094
1095         /**
1096          * Get the simulationContextService.
1097          * 
1098          * @return the simulationContextService
1099          */
1100         public SimulationContextService getSimulationContextService() {
1101                 return _simulationContextService;
1102         }
1103
1104         /**
1105          * Set the simulationContextService.
1106          * 
1107          * @param simulationContextService
1108          *            the simulationContextService to set
1109          */
1110         public void setSimulationContextService(
1111                         final SimulationContextService simulationContextService) {
1112                 _simulationContextService = simulationContextService;
1113         }
1114
1115         /**
1116          * Get project settings.
1117          * 
1118          * @return Project settings service
1119          */
1120         private ProjectSettingsService getProjectSettings() {
1121                 return _projectSettings;
1122         }
1123
1124         /**
1125          * Set project settings service.
1126          * 
1127          * @param projectSettingsService
1128          *            project settings service
1129          */
1130         public void setProjectSettings(
1131                         final ProjectSettingsService projectSettingsService) {
1132                 _projectSettings = projectSettingsService;
1133         }
1134
1135         /**
1136          * Get the documentTypeService.
1137          * 
1138          * @return the documentTypeService
1139          */
1140         public DocumentTypeService getDocumentTypeService() {
1141                 return _documentTypeService;
1142         }
1143
1144         /**
1145          * Set the documentTypeService.
1146          * 
1147          * @param documentTypeService
1148          *            the documentTypeService to set
1149          */
1150         public void setDocumentTypeService(
1151                         final DocumentTypeService documentTypeService) {
1152                 _documentTypeService = documentTypeService;
1153         }
1154
1155         /**
1156          * Get the roleDAO.
1157          * 
1158          * @return the roleDAO
1159          */
1160         public RoleDAO getRoleDAO() {
1161                 return _roleDAO;
1162         }
1163
1164         /**
1165          * Set the roleDAO.
1166          * 
1167          * @param roleDAO
1168          *            the roleDAO to set
1169          */
1170         public void setRoleDAO(final RoleDAO roleDAO) {
1171                 _roleDAO = roleDAO;
1172         }
1173
1174 }