1 /*****************************************************************************
5 * Creation date 06.10.2012
8 *****************************************************************************/
10 package org.splat.service;
12 import java.io.IOException;
13 import java.util.Calendar;
14 import java.util.Iterator;
15 import java.util.List;
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.kernel.UserDAO;
26 import org.splat.dal.dao.som.KnowledgeElementDAO;
27 import org.splat.dal.dao.som.KnowledgeElementTypeDAO;
28 import org.splat.dal.dao.som.ScenarioDAO;
29 import org.splat.dal.dao.som.StudyDAO;
30 import org.splat.kernel.InvalidPropertyException;
31 import org.splat.kernel.MissedPropertyException;
32 import org.splat.kernel.MultiplyDefinedException;
33 import org.splat.service.technical.IndexService;
34 import org.splat.som.Step;
35 import org.springframework.transaction.annotation.Transactional;
38 * Scenario service implementation.
40 * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
42 public class ScenarioServiceImpl implements ScenarioService {
45 * Logger for this class.
47 protected final static Logger LOG = Logger
48 .getLogger(ScenarioServiceImpl.class);
51 * Injected index service.
53 private IndexService _indexService;
55 * Injected step service.
57 private StepService _stepService;
59 * Injected study service.
61 private StudyService _studyService;
63 * Injected publication service.
65 private PublicationService _publicationService;
67 * Injected project element service.
69 private ProjectElementService _projectElementService;
71 * Injected knowledge element DAO.
73 private KnowledgeElementDAO _knowledgeElementDAO;
75 * Injected scenario DAO.
77 private ScenarioDAO _scenarioDAO;
82 private StudyDAO _studyDAO;
85 * Injected knowledge element service.
87 private KnowledgeElementTypeService _knowledgeElementTypeService;
90 * Injected user service.
92 private UserService _userService;
97 private UserDAO _userDAO;
100 * Injected knowledge element type DAO.
102 private KnowledgeElementTypeDAO _knowledgeElementTypeDAO;
105 * Injected simulation context service.
107 private SimulationContextService _simulationContextService;
110 * Get the projectElementService.
112 * @return the projectElementService
114 public ProjectElementService getProjectElementService() {
115 return _projectElementService;
119 * Set the projectElementService.
121 * @param projectElementService
122 * the projectElementService to set
124 public void setProjectElementService(
125 final ProjectElementService projectElementService) {
126 _projectElementService = projectElementService;
130 * Get the publicationService.
132 * @return the publicationService
134 public PublicationService getPublicationService() {
135 return _publicationService;
139 * Set the publicationService.
141 * @param publicationService
142 * the publicationService to set
144 public void setPublicationService(final PublicationService publicationService) {
145 _publicationService = publicationService;
149 * Get the stepService.
151 * @return the stepService
153 public StepService getStepService() {
158 * Set the stepService.
161 * the stepService to set
163 public void setStepService(final StepService stepService) {
164 _stepService = stepService;
168 * Create a new study with one scenario and "product" simulation context.
171 * the study properties
173 * the scenario properties
175 * the "product" simulation context properties
176 * @return the created study
177 * @throws MissedPropertyException
178 * if a mandatory property is missed
179 * @throws InvalidPropertyException
180 * if a property is invalid
181 * @throws MultiplyDefinedException
182 * if some property occurs several times
185 public Study createStudy(final Study.Properties sprop, final Scenario.Properties oprop,
186 final SimulationContext.Properties cprop) throws MissedPropertyException,
187 InvalidPropertyException, MultiplyDefinedException {
188 Study study = getStudyService().createStudy(sprop);
189 addScenario(study, oprop);
190 if (cprop.getIndex() == 0) { // Input of new project context
191 cprop.setType(getSimulationContextService().selectType("product"))
192 .setValue(cprop.getValue());
193 getStudyService().addProjectContext(study, cprop);
194 } else { // Selection of existing project context
195 SimulationContext context = getSimulationContextService()
196 .selectSimulationContext(cprop.getIndex());
197 getStudyService().addProjectContext(study, context);
205 * @see org.splat.service.ScenarioService#addKnowledgeElement(org.splat.dal.bo.som.Scenario,
206 * org.splat.dal.bo.som.KnowledgeElement.Properties)
209 public KnowledgeElement addKnowledgeElement(final Scenario aScenarioDTO,
210 final KnowledgeElement.Properties kprop) throws MissedPropertyException,
211 InvalidPropertyException, MultiplyDefinedException {
212 KnowledgeElement kelm = null;
214 long aScenarioId = aScenarioDTO.getIndex();
215 if (LOG.isDebugEnabled()) {
216 LOG.debug("Add a knowledge element to the scenario #"
219 // Get the persistent scenario.
220 Scenario aScenario = getScenarioDAO().get(aScenarioId);
221 // Get persistent objects for creating a new knowledge.
222 // TODO: Actions must use DTO instead of persistent objects.
223 getUserDAO().merge(kprop.getAuthor());
224 getKnowledgeElementTypeDAO().merge(kprop.getType());
225 // Create a transient knowledge element related to the given scenario.
226 kelm = new KnowledgeElement(kprop.setOwnerScenario(aScenario));
227 // Save the new knowledge in the database.
228 getKnowledgeElementDAO().create(kelm);
229 // Update scenario transient data.
230 if (kelm.getType().equals("usecase")) {
231 aScenarioDTO.setUcase(kelm);
232 } else if (aScenarioDTO.getKnowledgeElementsList() != null) { // If null, knowl will be initialized when needed
233 aScenarioDTO.getKnowledgeElementsList().add(kelm);
236 // Load the workflow for the parent study to take into account
237 // all study actors durng reindexing.
238 getStudyService().loadWorkflow(aScenario.getOwnerStudy());
240 // Update the lucene index of knowledge elements.
241 getIndexService().add(kelm);
242 if (LOG.isDebugEnabled()) {
243 LOG.debug("A knowledge element #" + kelm.getIndex()
244 + " is added to the scenario #" + aScenario.getIndex());
246 } catch (IOException error) {
247 LOG.error("Unable to index the knowedge element '"
248 + kelm.getIndex() + "', reason:", error);
256 * Update the scenario in the database.
259 * the scenario to update
260 * @return true if updating succeeded
263 private boolean update(final Scenario aScenario) {
264 boolean isOk = false;
266 getScenarioDAO().update(aScenario); // Update of relational base
268 } catch (Exception error) {
269 LOG.error("Unable to re-index the knowledge element '"
270 + aScenario.getIndex() + "', reason:", error);
278 * @see org.splat.service.ScenarioService#checkin(org.splat.dal.bo.som.Scenario)
280 public void checkin(final Scenario aScenario) {
281 aScenario.setUser(null);
282 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
283 getScenarioDAO().update(aScenario);
289 * @see org.splat.service.ScenarioService#checkout(org.splat.dal.bo.som.Scenario, org.splat.dal.bo.kernel.User)
291 public boolean checkout(final Scenario aScenario, final User user) {
292 if (!getStudyService().isStaffedBy(aScenario.getOwnerStudy(), user)) {
296 aScenario.setUser(user);
297 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
298 getScenarioDAO().update(aScenario);
305 * @see org.splat.service.ScenarioService#copyContentsUpTo(org.splat.dal.bo.som.Scenario, org.splat.som.Step)
307 public void copyContentsUpTo(final Scenario scenario, final Step lastep) {
308 Scenario base = (Scenario) lastep.getOwner();
309 Step[] from = getProjectElementService().getSteps(base);
310 Step[] to = getProjectElementService().getSteps(scenario);
311 for (int i = 0; i < from.length; i++) {
313 if (step.getNumber() > lastep.getNumber()) {
317 List<Publication> docs = step.getAllDocuments();
318 for (Iterator<Publication> j = docs.iterator(); j.hasNext();) {
319 Publication doc = getPublicationService().copy(j.next(),
320 scenario); // Creation of a new reference to the document
321 // Database.getSession().save(doc); Publications MUST be saved later through cascading when saving the scenario
322 getStepService().add(to[i], doc);
324 List<SimulationContext> ctex = step.getAllSimulationContexts();
325 for (Iterator<SimulationContext> j = ctex.iterator(); j.hasNext();) {
326 getStepService().addSimulationContext(to[i], j.next());
334 * @see org.splat.service.ScenarioService#isEmpty(org.splat.dal.bo.som.Scenario)
336 public boolean isEmpty(final Scenario scenario) {
337 Step[] mystep = getProjectElementService().getSteps(scenario);
338 boolean isEmp = true;
339 for (int i = 0; i < mystep.length; i++) {
340 if (mystep[i].isStarted()) {
352 public boolean isFinished(final Scenario scenario) {
353 Step[] mystep = getProjectElementService().getSteps(scenario);
354 boolean notempty = false; // If this is empty, this is not finished
355 for (int i = 0; i < mystep.length; i++) {
356 if (!mystep[i].isStarted()) {
359 if (!mystep[i].isFinished()) {
370 * @see org.splat.service.StudyService#addScenario(org.splat.dal.bo.som.Study, org.splat.dal.bo.som.Scenario.Properties)
373 public Scenario addScenario(final Study aStudy, final Scenario.Properties sprop)
374 throws MissedPropertyException, InvalidPropertyException,
375 MultiplyDefinedException {
376 if (sprop.getManager() == null) {
377 sprop.setManager(aStudy.getAuthor());
380 Scenario scenario = new Scenario(sprop.setOwnerStudy(aStudy));
381 if (sprop.getBaseStep() != null) {
382 copyContentsUpTo(scenario, sprop.getBaseStep());
384 Scenario previous = sprop.getInsertAfter();
386 if (previous == null) {
387 aStudy.getScenariiList().add(scenario);
389 aStudy.getScenariiList().add(
390 aStudy.getScenariiList().indexOf(previous) + 1, scenario);
392 getStudyDAO().update(aStudy); // No need to update the Lucene index
393 getScenarioDAO().create(scenario); // Must be done after updating this study because of the back reference to the study
394 if (sprop.getBaseStep() != null) {
395 // No need to update the Knowledge Element index as Knowledge Elements are not copied
396 getProjectElementService().refresh(scenario); // Because saving the scenario changes the hashcode of copied Publications
398 KnowledgeElementType ucase = getKnowledgeElementTypeService()
399 .selectType("usecase");
400 KnowledgeElement.Properties kprop = new KnowledgeElement.Properties();
401 User admin = getUserService().selectUser(1); // First user created when creating the database
402 kprop.setType(ucase).setTitle(aStudy.getTitle()).setValue(
403 scenario.getTitle()).setAuthor(admin); // Internal Knowledge Element required by the validation process of
405 addKnowledgeElement(scenario, kprop);
410 * Remove a knowledge element from a scenario.
415 * the knowledge element to remove
416 * @return true if removal succeeded
418 public boolean removeKnowledgeElement(final Scenario scenario,
419 final KnowledgeElement kelm) {
420 KnowledgeElement torem = scenario.getKnowledgeElement(kelm.getIndex());
424 boolean done = scenario.getKnowledgeElements().remove(torem);
426 // Update of my transient data
427 // RKV: These transient data are not used indeed.
428 // RKV: List<KnowledgeElement> kelms = scenario.getKnowledgeByType().get(
429 // RKV: kelm.getType().getIndex());
430 // RKV: kelms.remove(torem);
431 if (scenario.getKnowledgeElementsList() != null) {
432 scenario.getKnowledgeElementsList().remove(torem);
434 getScenarioDAO().update(scenario);
435 // TODO: If the owner study is not private, remove the knowledge from the Lucene index
443 * Get the knowledgeElementDAO.
445 * @return the knowledgeElementDAO
447 public KnowledgeElementDAO getKnowledgeElementDAO() {
448 return _knowledgeElementDAO;
452 * Set the knowledgeElementDAO.
454 * @param knowledgeElementDAO
455 * the knowledgeElementDAO to set
457 public void setKnowledgeElementDAO(final KnowledgeElementDAO knowledgeElementDAO) {
458 _knowledgeElementDAO = knowledgeElementDAO;
462 * Get the indexService.
464 * @return the indexService
466 public IndexService getIndexService() {
467 return _indexService;
471 * Set the indexService.
473 * @param indexService
474 * the indexService to set
476 public void setIndexService(final IndexService indexService) {
477 _indexService = indexService;
481 * Get the scenarioDAO.
483 * @return the scenarioDAO
485 public ScenarioDAO getScenarioDAO() {
490 * Set the scenarioDAO.
493 * the scenarioDAO to set
495 public void setScenarioDAO(final ScenarioDAO scenarioDAO) {
496 _scenarioDAO = scenarioDAO;
502 * @return the studyDAO
504 public StudyDAO getStudyDAO() {
512 * the studyDAO to set
514 public void setStudyDAO(final StudyDAO studyDAO) {
515 _studyDAO = studyDAO;
519 * Get the knowledgeElementTypeService.
521 * @return the knowledgeElementTypeService
523 public KnowledgeElementTypeService getKnowledgeElementTypeService() {
524 return _knowledgeElementTypeService;
528 * Set the knowledgeElementTypeService.
530 * @param knowledgeElementTypeService
531 * the knowledgeElementTypeService to set
533 public void setKnowledgeElementTypeService(
534 final KnowledgeElementTypeService knowledgeElementTypeService) {
535 _knowledgeElementTypeService = knowledgeElementTypeService;
539 * Get the studyService.
541 * @return the studyService
543 public StudyService getStudyService() {
544 return _studyService;
548 * Set the studyService.
550 * @param studyService
551 * the studyService to set
553 public void setStudyService(final StudyService studyService) {
554 _studyService = studyService;
558 * Get the userService.
560 * @return the userService
562 public UserService getUserService() {
567 * Set the userService.
570 * the userService to set
572 public void setUserService(final UserService userService) {
573 _userService = userService;
579 * @return the userDAO
581 public UserDAO getUserDAO() {
591 public void setUserDAO(final UserDAO userDAO) {
596 * Get the knowledgeElementTypeDAO.
598 * @return the knowledgeElementTypeDAO
600 public KnowledgeElementTypeDAO getKnowledgeElementTypeDAO() {
601 return _knowledgeElementTypeDAO;
605 * Set the knowledgeElementTypeDAO.
607 * @param knowledgeElementTypeDAO
608 * the knowledgeElementTypeDAO to set
610 public void setKnowledgeElementTypeDAO(
611 final KnowledgeElementTypeDAO knowledgeElementTypeDAO) {
612 _knowledgeElementTypeDAO = knowledgeElementTypeDAO;
616 * Get the simulationContextService.
618 * @return the simulationContextService
620 public SimulationContextService getSimulationContextService() {
621 return _simulationContextService;
625 * Set the simulationContextService.
627 * @param simulationContextService
628 * the simulationContextService to set
630 public void setSimulationContextService(
631 final SimulationContextService simulationContextService) {
632 _simulationContextService = simulationContextService;