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.som.KnowledgeElementDAO;
26 import org.splat.dal.dao.som.ScenarioDAO;
27 import org.splat.dal.dao.som.StudyDAO;
28 import org.splat.kernel.InvalidPropertyException;
29 import org.splat.kernel.MissedPropertyException;
30 import org.splat.kernel.MultiplyDefinedException;
31 import org.splat.service.technical.IndexService;
32 import org.splat.som.Step;
33 import org.springframework.transaction.annotation.Transactional;
36 * Scenario service implementation.
38 * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
40 public class ScenarioServiceImpl implements ScenarioService {
43 * Logger for this class.
45 protected final static Logger logger = Logger
46 .getLogger(ScenarioServiceImpl.class);
49 * Injected index service.
51 private IndexService _indexService;
53 * Injected step service.
55 private StepService _stepService;
57 * Injected study service.
59 private StudyService _studyService;
61 * Injected publication service.
63 private PublicationService _publicationService;
65 * Injected project element service.
67 private ProjectElementService _projectElementService;
69 * Injected knowledge element DAO.
71 private KnowledgeElementDAO _knowledgeElementDAO;
73 * Injected scenario DAO.
75 private ScenarioDAO _scenarioDAO;
80 private StudyDAO _studyDAO;
83 * Injected knowledge element service.
85 private KnowledgeElementTypeService _knowledgeElementTypeService;
88 * Injected user service.
90 private UserService _userService;
93 * Get the projectElementService.
95 * @return the projectElementService
97 public ProjectElementService getProjectElementService() {
98 return _projectElementService;
102 * Set the projectElementService.
104 * @param projectElementService
105 * the projectElementService to set
107 public void setProjectElementService(
108 ProjectElementService projectElementService) {
109 _projectElementService = projectElementService;
113 * Get the publicationService.
115 * @return the publicationService
117 public PublicationService getPublicationService() {
118 return _publicationService;
122 * Set the publicationService.
124 * @param publicationService
125 * the publicationService to set
127 public void setPublicationService(PublicationService publicationService) {
128 _publicationService = publicationService;
132 * Get the stepService.
134 * @return the stepService
136 public StepService getStepService() {
141 * Set the stepService.
144 * the stepService to set
146 public void setStepService(StepService stepService) {
147 _stepService = stepService;
153 * @see org.splat.service.ScenarioService#addKnowledgeElement(org.splat.dal.bo.som.Scenario,
154 * org.splat.dal.bo.som.KnowledgeElement.Properties)
157 public KnowledgeElement addKnowledgeElement(Scenario aScenario,
158 KnowledgeElement.Properties kprop) throws MissedPropertyException,
159 InvalidPropertyException, MultiplyDefinedException {
160 KnowledgeElement kelm = null;
162 // Attach the detached scenario to the new hibernate session.
163 aScenario = getScenarioDAO().merge(aScenario); // RKV
164 kelm = new KnowledgeElement(kprop.setOwnerScenario(aScenario));
165 getKnowledgeElementDAO().create(kelm);
166 // RKV: commented because of BatchUpdateException during creation of a new study: session.flush(); //RKV
167 // Update of my persistent data
168 // RKV aScenario.getKnowledgeElements().add(kelm);
169 // RKV getKnowledgeElementDAO().flush();
170 // RKV: commented because of NullPointerException during creation of a new study: session.merge(aScenario); //RKV
171 // Update of my transient data
172 List<KnowledgeElement> known = aScenario
173 .getKnowledgeElementsOf(kelm.getType()); // Initializes this.known, if not yet done
174 // RKV: knowledge is already added into persistent set and "known" is constructed from it in the above call: known.add(kelm);
175 if (kelm.getType().equals("usecase")) {
176 aScenario.setUcase(kelm);
177 } else if (aScenario.getKnowledgeElementsList() != null) { // If null, knowl will be initialized when needed
178 aScenario.getKnowledgeElementsList().add(kelm);
180 // Update of the index of Knowledge Elements
181 getIndexService().add(kelm);
184 } catch (IOException error) {
186 "Unable to index the knowedge element '" + kelm.getIndex()
187 + "', reason:", error);
195 * Update the scenario in the database.
198 * the scenario to update
199 * @return true if updating succeeded
202 private boolean update(Scenario aScenario) {
203 boolean isOk = false;
205 getScenarioDAO().update(aScenario); // Update of relational base
207 } catch (Exception error) {
208 logger.error("Unable to re-index the knowledge element '"
209 + aScenario.getIndex() + "', reason:", error);
217 * @see org.splat.service.ScenarioService#checkin(org.splat.dal.bo.som.Scenario)
219 public void checkin(Scenario aScenario) {
220 aScenario.setUser(null);
221 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
222 getScenarioDAO().update(aScenario);
228 * @see org.splat.service.ScenarioService#checkout(org.splat.dal.bo.som.Scenario, org.splat.dal.bo.kernel.User)
230 public boolean checkout(Scenario aScenario, User user) {
231 if (!getStudyService().isStaffedBy(aScenario.getOwnerStudy(), user))
234 aScenario.setUser(user);
235 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
236 getScenarioDAO().update(aScenario);
243 * @see org.splat.service.ScenarioService#copyContentsUpTo(org.splat.dal.bo.som.Scenario, org.splat.som.Step)
245 public void copyContentsUpTo(Scenario scenario, Step lastep) {
246 Scenario base = (Scenario) lastep.getOwner();
247 Step[] from = getProjectElementService().getSteps(base);
248 Step[] to = getProjectElementService().getSteps(scenario);
249 for (int i = 0; i < from.length; i++) {
251 if (step.getNumber() > lastep.getNumber())
254 List<Publication> docs = step.getAllDocuments();
255 for (Iterator<Publication> j = docs.iterator(); j.hasNext();) {
256 Publication doc = getPublicationService().copy(j.next(),
257 scenario); // Creation of a new reference to the document
258 // Database.getSession().save(doc); Publications MUST be saved later through cascading when saving the scenario
259 getStepService().add(to[i], doc);
261 List<SimulationContext> ctex = step.getAllSimulationContexts();
262 for (Iterator<SimulationContext> j = ctex.iterator(); j.hasNext();) {
263 getStepService().addSimulationContext(to[i], j.next());
271 * @see org.splat.service.ScenarioService#isEmpty(org.splat.dal.bo.som.Scenario)
273 public boolean isEmpty(Scenario scenario) {
274 Step[] mystep = getProjectElementService().getSteps(scenario);
275 boolean isEmp = true;
276 for (int i = 0; i < mystep.length; i++) {
277 if (mystep[i].isStarted()) {
289 public boolean isFinished(Scenario scenario) {
290 Step[] mystep = getProjectElementService().getSteps(scenario);
291 boolean notempty = false; // If this is empty, this is not finished
292 for (int i = 0; i < mystep.length; i++) {
293 if (!mystep[i].isStarted())
295 if (!mystep[i].isFinished())
305 * @see org.splat.service.StudyService#addScenario(org.splat.dal.bo.som.Study, org.splat.dal.bo.som.Scenario.Properties)
308 public Scenario addScenario(Study aStudy, Scenario.Properties sprop)
309 throws MissedPropertyException, InvalidPropertyException,
310 MultiplyDefinedException {
311 if (sprop.getManager() == null)
312 sprop.setManager(aStudy.getAuthor());
314 Scenario scenario = new Scenario(sprop.setOwnerStudy(aStudy));
315 if (sprop.getBaseStep() != null)
316 copyContentsUpTo(scenario, sprop.getBaseStep());
317 Scenario previous = sprop.getInsertAfter();
319 if (previous == null) {
320 aStudy.getScenariiList().add(scenario);
322 aStudy.getScenariiList().add(
323 aStudy.getScenariiList().indexOf(previous) + 1, scenario);
325 getStudyDAO().update(aStudy); // No need to update the Lucene index
326 getScenarioDAO().create(scenario); // Must be done after updating this study because of the back reference to the study
327 if (sprop.getBaseStep() != null) {
328 // No need to update the Knowledge Element index as Knowledge Elements are not copied
329 getProjectElementService().refresh(scenario); // Because saving the scenario changes the hashcode of copied Publications
331 KnowledgeElementType ucase = getKnowledgeElementTypeService()
332 .selectType("usecase");
333 KnowledgeElement.Properties kprop = new KnowledgeElement.Properties();
334 User admin = getUserService().selectUser(1); // First user created when creating the database
335 kprop.setType(ucase).setTitle(aStudy.getTitle())
336 .setValue(scenario.getTitle()).setAuthor(admin); // Internal Knowledge Element required by the validation process of
338 addKnowledgeElement(scenario, kprop);
343 * Remove a knowledge element from a scenario.
348 * the knowledge element to remove
349 * @return true if removal succeeded
351 public boolean removeKnowledgeElement(Scenario scenario,
352 KnowledgeElement kelm) {
353 // -------------------------------------------------------------
354 KnowledgeElement torem = scenario.getKnowledgeElement(kelm.getIndex());
357 boolean done = scenario.getKnowledgeElements().remove(torem);
359 // Update of my transient data
360 List<KnowledgeElement> kelms = scenario.getKnowledgeByType().get(
361 kelm.getType().getIndex());
363 if (scenario.getKnowledgeElementsList() != null)
364 scenario.getKnowledgeElementsList().remove(torem);
365 getScenarioDAO().update(scenario);
366 // TODO: If the owner study is not private, remove the knowledge from the Lucene index
374 * Get the knowledgeElementDAO.
376 * @return the knowledgeElementDAO
378 public KnowledgeElementDAO getKnowledgeElementDAO() {
379 return _knowledgeElementDAO;
383 * Set the knowledgeElementDAO.
385 * @param knowledgeElementDAO
386 * the knowledgeElementDAO to set
388 public void setKnowledgeElementDAO(KnowledgeElementDAO knowledgeElementDAO) {
389 _knowledgeElementDAO = knowledgeElementDAO;
393 * Get the indexService.
395 * @return the indexService
397 public IndexService getIndexService() {
398 return _indexService;
402 * Set the indexService.
404 * @param indexService
405 * the indexService to set
407 public void setIndexService(IndexService indexService) {
408 _indexService = indexService;
412 * Get the scenarioDAO.
414 * @return the scenarioDAO
416 public ScenarioDAO getScenarioDAO() {
421 * Set the scenarioDAO.
424 * the scenarioDAO to set
426 public void setScenarioDAO(ScenarioDAO scenarioDAO) {
427 _scenarioDAO = scenarioDAO;
433 * @return the studyDAO
435 public StudyDAO getStudyDAO() {
443 * the studyDAO to set
445 public void setStudyDAO(StudyDAO studyDAO) {
446 _studyDAO = studyDAO;
450 * Get the knowledgeElementTypeService.
452 * @return the knowledgeElementTypeService
454 public KnowledgeElementTypeService getKnowledgeElementTypeService() {
455 return _knowledgeElementTypeService;
459 * Set the knowledgeElementTypeService.
461 * @param knowledgeElementTypeService
462 * the knowledgeElementTypeService to set
464 public void setKnowledgeElementTypeService(
465 KnowledgeElementTypeService knowledgeElementTypeService) {
466 _knowledgeElementTypeService = knowledgeElementTypeService;
470 * Get the studyService.
472 * @return the studyService
474 public StudyService getStudyService() {
475 return _studyService;
479 * Set the studyService.
481 * @param studyService
482 * the studyService to set
484 public void setStudyService(StudyService studyService) {
485 _studyService = studyService;
489 * Get the userService.
490 * @return the userService
492 public UserService getUserService() {
497 * Set the userService.
498 * @param userService the userService to set
500 public void setUserService(UserService userService) {
501 _userService = userService;