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.kernel.UserDirectory;
32 import org.splat.service.technical.IndexService;
33 import org.splat.som.Step;
34 import org.springframework.transaction.annotation.Transactional;
37 * Scenario service implementation.
39 * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
41 public class ScenarioServiceImpl implements ScenarioService {
44 * Logger for this class.
46 protected final static Logger logger = Logger
47 .getLogger(ScenarioServiceImpl.class);
50 * Injected index service.
52 private IndexService _indexService;
54 * Injected step service.
56 private StepService _stepService;
58 * Injected study service.
60 private StudyService _studyService;
62 * Injected publication service.
64 private PublicationService _publicationService;
66 * Injected project element service.
68 private ProjectElementService _projectElementService;
70 * Injected knowledge element DAO.
72 private KnowledgeElementDAO _knowledgeElementDAO;
74 * Injected scenario DAO.
76 private ScenarioDAO _scenarioDAO;
81 private StudyDAO _studyDAO;
84 * Injected knowledge element service.
86 private KnowledgeElementTypeService _knowledgeElementTypeService;
89 * Get the projectElementService.
91 * @return the projectElementService
93 public ProjectElementService getProjectElementService() {
94 return _projectElementService;
98 * Set the projectElementService.
100 * @param projectElementService
101 * the projectElementService to set
103 public void setProjectElementService(
104 ProjectElementService projectElementService) {
105 _projectElementService = projectElementService;
109 * Get the publicationService.
111 * @return the publicationService
113 public PublicationService getPublicationService() {
114 return _publicationService;
118 * Set the publicationService.
120 * @param publicationService
121 * the publicationService to set
123 public void setPublicationService(PublicationService publicationService) {
124 _publicationService = publicationService;
128 * Get the stepService.
130 * @return the stepService
132 public StepService getStepService() {
137 * Set the stepService.
140 * the stepService to set
142 public void setStepService(StepService stepService) {
143 _stepService = stepService;
149 * @see org.splat.service.ScenarioService#addKnowledgeElement(org.splat.dal.bo.som.Scenario,
150 * org.splat.dal.bo.som.KnowledgeElement.Properties)
153 public KnowledgeElement addKnowledgeElement(Scenario aScenario,
154 KnowledgeElement.Properties kprop) throws MissedPropertyException,
155 InvalidPropertyException, MultiplyDefinedException {
156 KnowledgeElement kelm = null;
158 // Attach the detached scenario to the new hibernate session.
159 aScenario = getScenarioDAO().merge(aScenario); // RKV
160 kelm = new KnowledgeElement(kprop.setOwnerScenario(aScenario));
161 getKnowledgeElementDAO().create(kelm);
162 // RKV: commented because of BatchUpdateException during creation of a new study: session.flush(); //RKV
163 // Update of my persistent data
164 // RKV aScenario.getKnowledgeElements().add(kelm);
165 // RKV getKnowledgeElementDAO().flush();
166 // RKV: commented because of NullPointerException during creation of a new study: session.merge(aScenario); //RKV
167 // Update of my transient data
168 List<KnowledgeElement> known = aScenario
169 .getKnowledgeElementsOf(kelm.getType()); // Initializes this.known, if not yet done
170 // RKV: knowledge is already added into persistent set and "known" is constructed from it in the above call: known.add(kelm);
171 if (kelm.getType().equals("usecase")) {
172 aScenario.setUcase(kelm);
173 } else if (aScenario.getKnowledgeElementsList() != null) { // If null, knowl will be initialized when needed
174 aScenario.getKnowledgeElementsList().add(kelm);
176 // Update of the index of Knowledge Elements
177 getIndexService().add(kelm);
180 } catch (IOException error) {
181 logger.error("Unable to index the knowedge element '"
182 + kelm.getIndex() + "', reason:", error);
190 * Update the scenario in the database.
193 * the scenario to update
194 * @return true if updating succeeded
197 private boolean update(Scenario aScenario) {
198 boolean isOk = false;
200 getScenarioDAO().update(aScenario); // Update of relational base
202 } catch (Exception error) {
203 logger.error("Unable to re-index the knowledge element '"
204 + aScenario.getIndex() + "', reason:", error);
212 * @see org.splat.service.ScenarioService#checkin(org.splat.dal.bo.som.Scenario)
214 public void checkin(Scenario aScenario) {
215 aScenario.setUser(null);
216 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
217 getScenarioDAO().update(aScenario);
223 * @see org.splat.service.ScenarioService#checkout(org.splat.dal.bo.som.Scenario, org.splat.dal.bo.kernel.User)
225 public boolean checkout(Scenario aScenario, User user) {
226 if (!getStudyService().isStaffedBy(aScenario.getOwnerStudy(), user))
229 aScenario.setUser(user);
230 aScenario.setLastModificationDate(Calendar.getInstance().getTime());
231 getScenarioDAO().update(aScenario);
238 * @see org.splat.service.ScenarioService#copyContentsUpTo(org.splat.dal.bo.som.Scenario, org.splat.som.Step)
240 public void copyContentsUpTo(Scenario scenario, Step lastep) {
241 Scenario base = (Scenario) lastep.getOwner();
242 Step[] from = getProjectElementService().getSteps(base);
243 Step[] to = getProjectElementService().getSteps(scenario);
244 for (int i = 0; i < from.length; i++) {
246 if (step.getNumber() > lastep.getNumber())
249 List<Publication> docs = step.getAllDocuments();
250 for (Iterator<Publication> j = docs.iterator(); j.hasNext();) {
251 Publication doc = getPublicationService().copy(j.next(),
252 scenario); // Creation of a new reference to the document
253 // Database.getSession().save(doc); Publications MUST be saved later through cascading when saving the scenario
254 getStepService().add(to[i], doc);
256 List<SimulationContext> ctex = step.getAllSimulationContexts();
257 for (Iterator<SimulationContext> j = ctex.iterator(); j.hasNext();) {
258 getStepService().addSimulationContext(to[i], j.next());
266 * @see org.splat.service.ScenarioService#isEmpty(org.splat.dal.bo.som.Scenario)
268 public boolean isEmpty(Scenario scenario) {
269 Step[] mystep = getProjectElementService().getSteps(scenario);
270 boolean isEmp = true;
271 for (int i = 0; i < mystep.length; i++) {
272 if (mystep[i].isStarted()) {
284 public boolean isFinished(Scenario scenario) {
285 Step[] mystep = getProjectElementService().getSteps(scenario);
286 boolean notempty = false; // If this is empty, this is not finished
287 for (int i = 0; i < mystep.length; i++) {
288 if (!mystep[i].isStarted())
290 if (!mystep[i].isFinished())
300 * @see org.splat.service.StudyService#addScenario(org.splat.dal.bo.som.Study, org.splat.dal.bo.som.Scenario.Properties)
303 public Scenario addScenario(Study aStudy, Scenario.Properties sprop)
304 throws MissedPropertyException, InvalidPropertyException,
305 MultiplyDefinedException {
306 if (sprop.getManager() == null)
307 sprop.setManager(aStudy.getAuthor());
309 Scenario scenario = new Scenario(sprop.setOwnerStudy(aStudy));
310 if (sprop.getBaseStep() != null)
311 copyContentsUpTo(scenario, sprop.getBaseStep());
312 Scenario previous = sprop.getInsertAfter();
314 if (previous == null) {
315 aStudy.getScenariiList().add(scenario);
317 aStudy.getScenariiList().add(
318 aStudy.getScenariiList().indexOf(previous) + 1, scenario);
320 getStudyDAO().update(aStudy); // No need to update the Lucene index
321 getScenarioDAO().create(scenario); // Must be done after updating this study because of the back reference to the study
322 if (sprop.getBaseStep() != null) {
323 // No need to update the Knowledge Element index as Knowledge Elements are not copied
324 scenario.refresh(); // Because saving the scenario changes the hashcode of copied Publications
326 KnowledgeElementType ucase = getKnowledgeElementTypeService().selectType(
328 KnowledgeElement.Properties kprop = new KnowledgeElement.Properties();
329 User admin = UserDirectory.selectUser(1); // First user created when creating the database
330 kprop.setType(ucase).setTitle(aStudy.getTitle()).setValue(
331 scenario.getTitle()).setAuthor(admin); // Internal Knowledge Element required by the validation process of
333 addKnowledgeElement(scenario, kprop);
338 * Get the knowledgeElementDAO.
340 * @return the knowledgeElementDAO
342 public KnowledgeElementDAO getKnowledgeElementDAO() {
343 return _knowledgeElementDAO;
347 * Set the knowledgeElementDAO.
349 * @param knowledgeElementDAO
350 * the knowledgeElementDAO to set
352 public void setKnowledgeElementDAO(KnowledgeElementDAO knowledgeElementDAO) {
353 _knowledgeElementDAO = knowledgeElementDAO;
357 * Get the indexService.
359 * @return the indexService
361 public IndexService getIndexService() {
362 return _indexService;
366 * Set the indexService.
368 * @param indexService
369 * the indexService to set
371 public void setIndexService(IndexService indexService) {
372 _indexService = indexService;
376 * Get the scenarioDAO.
378 * @return the scenarioDAO
380 public ScenarioDAO getScenarioDAO() {
385 * Set the scenarioDAO.
388 * the scenarioDAO to set
390 public void setScenarioDAO(ScenarioDAO scenarioDAO) {
391 _scenarioDAO = scenarioDAO;
397 * @return the studyDAO
399 public StudyDAO getStudyDAO() {
407 * the studyDAO to set
409 public void setStudyDAO(StudyDAO studyDAO) {
410 _studyDAO = studyDAO;
414 * Get the knowledgeElementTypeService.
416 * @return the knowledgeElementTypeService
418 public KnowledgeElementTypeService getKnowledgeElementTypeService() {
419 return _knowledgeElementTypeService;
423 * Set the knowledgeElementTypeService.
425 * @param knowledgeElementTypeService
426 * the knowledgeElementTypeService to set
428 public void setKnowledgeElementTypeService(
429 KnowledgeElementTypeService knowledgeElementTypeService) {
430 _knowledgeElementTypeService = knowledgeElementTypeService;
434 * Get the studyService.
435 * @return the studyService
437 public StudyService getStudyService() {
438 return _studyService;
442 * Set the studyService.
443 * @param studyService the studyService to set
445 public void setStudyService(StudyService studyService) {
446 _studyService = studyService;