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 logger = 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 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(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(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(Study.Properties sprop, Scenario.Properties oprop,
186 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(Scenario aScenarioDTO,
210 KnowledgeElement.Properties kprop) throws MissedPropertyException,
211 InvalidPropertyException, MultiplyDefinedException {
212 KnowledgeElement kelm = null;
214 long aScenarioId = aScenarioDTO.getIndex();
215 if (logger.isDebugEnabled()) {
216 logger.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);
235 // Update the lucene index of knowledge elements.
236 getIndexService().add(kelm);
237 if (logger.isDebugEnabled()) {
238 logger.debug("A knowledge element #" + kelm.getIndex()
239 + " is added to the scenario #" + aScenario.getIndex());
241 } catch (IOException error) {
242 logger.error("Unable to index the knowedge element '"
243 + kelm.getIndex() + "', reason:", error);
251 * Update the scenario in the database.
254 * the scenario to update
255 * @return true if updating succeeded
258 private boolean update(Scenario aScenario) {
259 boolean isOk = false;
261 getScenarioDAO().update(aScenario); // Update of relational base
263 } catch (Exception error) {
264 logger.error("Unable to re-index the knowledge element '"
265 + aScenario.getIndex() + "', reason:", error);
273 * @see org.splat.service.ScenarioService#checkin(org.splat.dal.bo.som.Scenario)
275 public void checkin(Scenario aScenario) {
276 aScenario.setUser(null);
277 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
278 getScenarioDAO().update(aScenario);
284 * @see org.splat.service.ScenarioService#checkout(org.splat.dal.bo.som.Scenario, org.splat.dal.bo.kernel.User)
286 public boolean checkout(Scenario aScenario, User user) {
287 if (!getStudyService().isStaffedBy(aScenario.getOwnerStudy(), user))
290 aScenario.setUser(user);
291 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
292 getScenarioDAO().update(aScenario);
299 * @see org.splat.service.ScenarioService#copyContentsUpTo(org.splat.dal.bo.som.Scenario, org.splat.som.Step)
301 public void copyContentsUpTo(Scenario scenario, Step lastep) {
302 Scenario base = (Scenario) lastep.getOwner();
303 Step[] from = getProjectElementService().getSteps(base);
304 Step[] to = getProjectElementService().getSteps(scenario);
305 for (int i = 0; i < from.length; i++) {
307 if (step.getNumber() > lastep.getNumber())
310 List<Publication> docs = step.getAllDocuments();
311 for (Iterator<Publication> j = docs.iterator(); j.hasNext();) {
312 Publication doc = getPublicationService().copy(j.next(),
313 scenario); // Creation of a new reference to the document
314 // Database.getSession().save(doc); Publications MUST be saved later through cascading when saving the scenario
315 getStepService().add(to[i], doc);
317 List<SimulationContext> ctex = step.getAllSimulationContexts();
318 for (Iterator<SimulationContext> j = ctex.iterator(); j.hasNext();) {
319 getStepService().addSimulationContext(to[i], j.next());
327 * @see org.splat.service.ScenarioService#isEmpty(org.splat.dal.bo.som.Scenario)
329 public boolean isEmpty(Scenario scenario) {
330 Step[] mystep = getProjectElementService().getSteps(scenario);
331 boolean isEmp = true;
332 for (int i = 0; i < mystep.length; i++) {
333 if (mystep[i].isStarted()) {
345 public boolean isFinished(Scenario scenario) {
346 Step[] mystep = getProjectElementService().getSteps(scenario);
347 boolean notempty = false; // If this is empty, this is not finished
348 for (int i = 0; i < mystep.length; i++) {
349 if (!mystep[i].isStarted())
351 if (!mystep[i].isFinished())
361 * @see org.splat.service.StudyService#addScenario(org.splat.dal.bo.som.Study, org.splat.dal.bo.som.Scenario.Properties)
364 public Scenario addScenario(Study aStudy, Scenario.Properties sprop)
365 throws MissedPropertyException, InvalidPropertyException,
366 MultiplyDefinedException {
367 if (sprop.getManager() == null)
368 sprop.setManager(aStudy.getAuthor());
370 Scenario scenario = new Scenario(sprop.setOwnerStudy(aStudy));
371 if (sprop.getBaseStep() != null)
372 copyContentsUpTo(scenario, sprop.getBaseStep());
373 Scenario previous = sprop.getInsertAfter();
375 if (previous == null) {
376 aStudy.getScenariiList().add(scenario);
378 aStudy.getScenariiList().add(
379 aStudy.getScenariiList().indexOf(previous) + 1, scenario);
381 getStudyDAO().update(aStudy); // No need to update the Lucene index
382 getScenarioDAO().create(scenario); // Must be done after updating this study because of the back reference to the study
383 if (sprop.getBaseStep() != null) {
384 // No need to update the Knowledge Element index as Knowledge Elements are not copied
385 getProjectElementService().refresh(scenario); // Because saving the scenario changes the hashcode of copied Publications
387 KnowledgeElementType ucase = getKnowledgeElementTypeService()
388 .selectType("usecase");
389 KnowledgeElement.Properties kprop = new KnowledgeElement.Properties();
390 User admin = getUserService().selectUser(1); // First user created when creating the database
391 kprop.setType(ucase).setTitle(aStudy.getTitle()).setValue(
392 scenario.getTitle()).setAuthor(admin); // Internal Knowledge Element required by the validation process of
394 addKnowledgeElement(scenario, kprop);
399 * Remove a knowledge element from a scenario.
404 * the knowledge element to remove
405 * @return true if removal succeeded
407 public boolean removeKnowledgeElement(Scenario scenario,
408 KnowledgeElement kelm) {
409 KnowledgeElement torem = scenario.getKnowledgeElement(kelm.getIndex());
412 boolean done = scenario.getKnowledgeElements().remove(torem);
414 // Update of my transient data
415 // RKV: These transient data are not used indeed.
416 // RKV: List<KnowledgeElement> kelms = scenario.getKnowledgeByType().get(
417 // RKV: kelm.getType().getIndex());
418 // RKV: kelms.remove(torem);
419 if (scenario.getKnowledgeElementsList() != null)
420 scenario.getKnowledgeElementsList().remove(torem);
421 getScenarioDAO().update(scenario);
422 // TODO: If the owner study is not private, remove the knowledge from the Lucene index
430 * Get the knowledgeElementDAO.
432 * @return the knowledgeElementDAO
434 public KnowledgeElementDAO getKnowledgeElementDAO() {
435 return _knowledgeElementDAO;
439 * Set the knowledgeElementDAO.
441 * @param knowledgeElementDAO
442 * the knowledgeElementDAO to set
444 public void setKnowledgeElementDAO(KnowledgeElementDAO knowledgeElementDAO) {
445 _knowledgeElementDAO = knowledgeElementDAO;
449 * Get the indexService.
451 * @return the indexService
453 public IndexService getIndexService() {
454 return _indexService;
458 * Set the indexService.
460 * @param indexService
461 * the indexService to set
463 public void setIndexService(IndexService indexService) {
464 _indexService = indexService;
468 * Get the scenarioDAO.
470 * @return the scenarioDAO
472 public ScenarioDAO getScenarioDAO() {
477 * Set the scenarioDAO.
480 * the scenarioDAO to set
482 public void setScenarioDAO(ScenarioDAO scenarioDAO) {
483 _scenarioDAO = scenarioDAO;
489 * @return the studyDAO
491 public StudyDAO getStudyDAO() {
499 * the studyDAO to set
501 public void setStudyDAO(StudyDAO studyDAO) {
502 _studyDAO = studyDAO;
506 * Get the knowledgeElementTypeService.
508 * @return the knowledgeElementTypeService
510 public KnowledgeElementTypeService getKnowledgeElementTypeService() {
511 return _knowledgeElementTypeService;
515 * Set the knowledgeElementTypeService.
517 * @param knowledgeElementTypeService
518 * the knowledgeElementTypeService to set
520 public void setKnowledgeElementTypeService(
521 KnowledgeElementTypeService knowledgeElementTypeService) {
522 _knowledgeElementTypeService = knowledgeElementTypeService;
526 * Get the studyService.
528 * @return the studyService
530 public StudyService getStudyService() {
531 return _studyService;
535 * Set the studyService.
537 * @param studyService
538 * the studyService to set
540 public void setStudyService(StudyService studyService) {
541 _studyService = studyService;
545 * Get the userService.
547 * @return the userService
549 public UserService getUserService() {
554 * Set the userService.
557 * the userService to set
559 public void setUserService(UserService userService) {
560 _userService = userService;
566 * @return the userDAO
568 public UserDAO getUserDAO() {
578 public void setUserDAO(UserDAO userDAO) {
583 * Get the knowledgeElementTypeDAO.
585 * @return the knowledgeElementTypeDAO
587 public KnowledgeElementTypeDAO getKnowledgeElementTypeDAO() {
588 return _knowledgeElementTypeDAO;
592 * Set the knowledgeElementTypeDAO.
594 * @param knowledgeElementTypeDAO
595 * the knowledgeElementTypeDAO to set
597 public void setKnowledgeElementTypeDAO(
598 KnowledgeElementTypeDAO knowledgeElementTypeDAO) {
599 _knowledgeElementTypeDAO = knowledgeElementTypeDAO;
603 * Get the simulationContextService.
605 * @return the simulationContextService
607 public SimulationContextService getSimulationContextService() {
608 return _simulationContextService;
612 * Set the simulationContextService.
614 * @param simulationContextService
615 * the simulationContextService to set
617 public void setSimulationContextService(
618 SimulationContextService simulationContextService) {
619 _simulationContextService = simulationContextService;