Workspace/Siman-Common/src/org/splat/service/StepServiceImpl.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.List;
  15
  16 import org.hibernate.criterion.Restrictions;
  17 import org.splat.dal.bo.kernel.Relation;
  18 import org.splat.dal.bo.kernel.User;
  19 import org.splat.dal.bo.som.ConvertsRelation;
  20 import org.splat.dal.bo.som.Document;
  21 import org.splat.dal.bo.som.DocumentType;
  22 import org.splat.dal.bo.som.File;
  23 import org.splat.dal.bo.som.KnowledgeElement;
  24 import org.splat.dal.bo.som.ProjectElement;
  25 import org.splat.dal.bo.som.Publication;
  26 import org.splat.dal.bo.som.Scenario;
  27 import org.splat.dal.bo.som.SimulationContext;
  28 import org.splat.dal.bo.som.StepCommentAttribute;
  29 import org.splat.dal.bo.som.UsedByRelation;
  30 import org.splat.dal.bo.som.UsesRelation;
  31 import org.splat.dal.bo.som.VersionsRelation;
  32 import org.splat.dal.dao.kernel.RelationDAO;
  33 import org.splat.dal.dao.kernel.UserDAO;
  34 import org.splat.dal.dao.som.DocumentDAO;
  35 import org.splat.dal.dao.som.FileDAO;
  36 import org.splat.dal.dao.som.ProjectElementDAO;
  37 import org.splat.dal.dao.som.PublicationDAO;
  38 import org.splat.dal.dao.som.SimulationContextDAO;
  39 import org.splat.dal.dao.som.StepCommentAttributeDAO;
  40 import org.splat.dal.dao.som.VersionsRelationDAO;
  41 import org.splat.exception.DocumentIsUsedException;
  42 import org.splat.exception.InvalidParameterException;
  43 import org.splat.kernel.InvalidPropertyException;
  44 import org.splat.kernel.MismatchException;
  45 import org.splat.kernel.MissedPropertyException;
  46 import org.splat.kernel.MultiplyDefinedException;
  47 import org.splat.kernel.NotApplicableException;
  48 import org.splat.log.AppLogger;
  49 import org.splat.service.dto.StepCommentDTO;
  50 import org.splat.service.technical.IndexService;
  51 import org.splat.service.technical.ProjectSettingsService;
  52 import org.splat.som.Revision;
  53 import org.splat.som.Step;
  54 import org.splat.util.BeanHelper;
  55 import org.springframework.transaction.annotation.Transactional;
  56
  57 /**
  58  * Step service implementation.
  59  *
  60  * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
  61  */
  62 public class StepServiceImpl implements StepService {
  63
  64         /**
  65          * logger for the service.
  66          */
  67         public final static AppLogger LOG = AppLogger
  68                         .getLogger(StepServiceImpl.class);
  69         /**
  70          * Injected index service.
  71          */
  72         private IndexService _indexService;
  73         /**
  74          * Injected document service.
  75          */
  76         private DocumentService _documentService;
  77         /**
  78          * Injected document type service.
  79          */
  80         private DocumentTypeService _documentTypeService;
  81         /**
  82          * Injected document DAO.
  83          */
  84         private DocumentDAO _documentDAO;
  85         /**
  86          * Injected relation DAO.
  87          */
  88         private RelationDAO _relationDAO;
  89         /**
  90          * Injected file DAO.
  91          */
  92         private FileDAO _fileDAO;
  93         /**
  94          * Injected simulation context service.
  95          */
  96         private SimulationContextService _simulationContextService;
  97         /**
  98          * Injected simulation context DAO.
  99          */
 100         private SimulationContextDAO _simulationContextDAO;
 101         /**
 102          * Injected project element DAO.
 103          */
 104         private ProjectElementDAO _projectElementDAO;
 105         /**
 106          * Injected versions relation DAO.
 107          */
 108         private VersionsRelationDAO _versionsRelationDAO;
 109         /**
 110          * Injected project service.
 111          */
 112         private ProjectSettingsService _projectSettings;
 113         /**
 114          * Injected publication DAO.
 115          */
 116         private PublicationDAO _publicationDAO;
 117
 118         /**
 119          * Injected text attribute DAO.
 120          */
 121         private StepCommentAttributeDAO _stepCommentAttributeDAO;
 122
 123         /**
 124          * Injected user DAO.
 125          */
 126         private UserDAO _userDAO;
 127
 128         /**
 129          * {@inheritDoc}
 130          *
 131          * @see org.splat.service.StepService#addSimulationContext(org.splat.som.Step, org.splat.dal.bo.som.SimulationContext.Properties)
 132          */
 133         @Override
 134         public SimulationContext addSimulationContext(final Step aStep,
 135                         final SimulationContext.Properties dprop)
 136                         throws MissedPropertyException, InvalidPropertyException,
 137                         MultiplyDefinedException {
 138                 SimulationContext context = new SimulationContext(dprop.setStep(aStep
 139                                 .getStep()));
 140                 return addSimulationContext(aStep, context);
 141         }
 142
 143         /**
 144          * {@inheritDoc}
 145          *
 146          * @see org.splat.service.StepService#addSimulationContext(org.splat.som.Step, org.splat.dal.bo.som.SimulationContext)
 147          */
 148         @Override
 149         @Transactional
 150         public SimulationContext addSimulationContext(final Step aStep,
 151                         final SimulationContext context) {
 152                 SimulationContext res = null;
 153                 getSimulationContextService().hold(context); // Increments the reference count of simulation context
 154                 if (aStep.getOwner().isSaved()) {
 155                         try {
 156                                 if (!context.isSaved()) {
 157                                         getSimulationContextDAO().create(context);
 158                                 }
 159                                 aStep.getOwner().add(context);
 160                                 aStep.getContex().add(context); // The context is also referenced from this (transient) Step
 161                                 getProjectElementDAO().update(aStep.getOwner());
 162                                 updateKnowledgeElementsIndex(aStep);
 163                                 res = context;
 164                         } catch (Exception error) {
 165                                 LOG.debug(error.getMessage(), error);
 166                         }
 167                 } else { // Happens when copying a scenario
 168                         aStep.getOwner().add(context);
 169                         aStep.getContex().add(context); // The context is also referenced from this (transient) Step
 170                         // In case of owner scenario, the Knowledge Element index will be updated later, when saving the scenario
 171                         res = context;
 172                 }
 173                 return res;
 174         }
 175
 176         /**
 177          * Update lucene index of knowledge elements of a scenario or a study which the given step is related to.
 178          *
 179          * @param aStep
 180          *            the step (activity)
 181          */
 182         private void updateKnowledgeElementsIndex(final Step aStep) {
 183                 Scenario[] scenarii;
 184                 if (aStep.getOwner() instanceof Scenario) {
 185                         scenarii = new Scenario[1];
 186                         scenarii[0] = (Scenario) aStep.getOwner();
 187                 } else {
 188                         scenarii = aStep.getOwnerStudy().getScenarii();
 189                 }
 190                 for (int i = 0; i < scenarii.length; i++) {
 191                         Scenario scene = scenarii[i];
 192                         updateScenarioIndex(scene);
 193                 }
 194         }
 195
 196         /**
 197          * Update lucene index for knowledge elements of the scenario.
 198          *
 199          * @param scene
 200          *            the scenario
 201          */
 202         private void updateScenarioIndex(final Scenario scene) {
 203                 if (scene.getUcase() == null) {
 204                         for (KnowledgeElement kelm : scene.getKnowledgeElements()) {
 205                                 if (kelm.getType().equals("usecase")) {
 206                                         scene.setUcase(kelm);
 207                                         break;
 208                                 }
 209                         }
 210                 }
 211         }
 212
 213         /**
 214          * {@inheritDoc}
 215          *
 216          * @see org.splat.service.StepService#removeSimulationContext(org.splat.som.Step, org.splat.dal.bo.som.SimulationContext)
 217          */
 218         @Override
 219         @Transactional
 220         public boolean removeSimulationContext(final Step aStep,
 221                         final SimulationContext context) {
 222                 SimulationContext torem = aStep
 223                                 .getSimulationContext(context.getIndex());
 224
 225                 boolean isOk = (torem != null) && (aStep.getOwner().remove(torem));
 226                 if (isOk) {
 227
 228                         aStep.getContex().remove(torem);
 229                         getProjectElementDAO().update(aStep.getOwner());
 230                         if (torem.isShared()) {
 231                                 getSimulationContextService().release(torem);
 232                                 getSimulationContextDAO().update(torem);
 233                         } else {
 234                                 getSimulationContextDAO().delete(torem);
 235                         }
 236                 }
 237                 return isOk;
 238         }
 239
 240         /**
 241          * {@inheritDoc}
 242          *
 243          * @see org.splat.service.StepService#createDocument(org.splat.som.Step, org.splat.dal.bo.som.Document.Properties)
 244          */
 245         @Override
 246         @Transactional
 247         public Publication createDocument(final Step aStep,
 248                         final Document.Properties dprop) throws MissedPropertyException,
 249                         InvalidPropertyException, MultiplyDefinedException, IOException {
 250                 if (LOG.isDebugEnabled()) {
 251                         LOG.debug("Local index before: "
 252                                         + aStep.getOwnerStudy().getLastLocalIndex());
 253                 }
 254                 Document newdoc = new Document(dprop.setOwner(aStep.getOwner())
 255                                 .setStep(aStep.getStep()));
 256                 getDocumentService().generateDocumentId(newdoc, dprop);
 257
 258                 // Creation of the save directory
 259                 java.io.File wdir = getDocumentService().getSaveDirectory(newdoc);
 260                 if ((!wdir.exists()) && (!wdir.mkdirs())) {
 261                         throw new IOException(
 262                                         "Cannot create the repository vault directory");
 263                 }
 264
 265                 // Identification and save
 266                 if (LOG.isDebugEnabled()) {
 267                         LOG.debug("Local index after: "
 268                                         + aStep.getOwnerStudy().getLastLocalIndex());
 269                 }
 270                 getDocumentService().buildReferenceFrom(newdoc, aStep.getOwnerStudy());
 271                 getDocumentDAO().create(newdoc);
 272
 273                 return new Publication(newdoc, aStep.getOwner());
 274         }
 275
 276         /**
 277          * {@inheritDoc}
 278          *
 279          * @see org.splat.service.StepService#assignDocument(org.splat.som.Step, org.splat.dal.bo.som.Document.Properties)
 280          */
 281         @Override
 282         public Publication assignDocument(final Step aStep,
 283                         final Document.Properties dprop) throws MissedPropertyException,
 284                         InvalidPropertyException, NotApplicableException {
 285                 String refid = dprop.getReference();
 286                 Publication res = null;
 287                 if (refid != null) {
 288                         Document slot = getDocumentService().selectDocument(refid,
 289                                         new Revision().toString());
 290                         if ((slot != null) && (slot.isUndefined())) {
 291                                 getDocumentService().initialize(slot,
 292                                                 dprop.setOwner(aStep.getOwnerStudy()));
 293                                 res = new Publication(slot, aStep.getOwner());
 294                         }
 295                 }
 296                 return res;
 297         }
 298
 299         /**
 300          * Create a new version of a document in the given study step.
 301          *
 302          * @param aStep
 303          *            the study step
 304          * @param base
 305          *            the base document published version
 306          * @return the new version publication
 307          * @throws MissedPropertyException
 308          *             if a mandatory property is missed
 309          * @throws InvalidPropertyException
 310          *             if some property doesn't exist
 311          * @throws MultiplyDefinedException
 312          *             if some property is defined several times
 313          * @throws IOException
 314          *             if a file system error occurs
 315          * @throws MismatchException
 316          *             if the document is not applicable to the given study step
 317          */
 318         public Publication versionDocument(final Step aStep, final Publication base)
 319                         throws MissedPropertyException, InvalidPropertyException,
 320                         MultiplyDefinedException, IOException, MismatchException {
 321                 return versionDocument(aStep, base, new Document.Properties());
 322         }
 323
 324         /**
 325          * Create a new version of a document in the given study step.
 326          *
 327          * @param aStep
 328          *            the study step
 329          * @param base
 330          *            the base document published version
 331          * @param reason
 332          *            the comment for the new version
 333          * @return the new version publication
 334          * @throws MissedPropertyException
 335          *             if a mandatory property is missed
 336          * @throws InvalidPropertyException
 337          *             if some property doesn't exist
 338          * @throws MultiplyDefinedException
 339          *             if some property is defined several times
 340          * @throws IOException
 341          *             if a file system error occurs
 342          * @throws MismatchException
 343          *             if the document is not applicable to the given study step
 344          */
 345         public Publication versionDocument(final Step aStep,
 346                         final Publication base, final String reason)
 347                         throws MissedPropertyException, InvalidPropertyException,
 348                         MultiplyDefinedException, IOException, MismatchException {
 349                 return versionDocument(aStep, base, new Document.Properties()
 350                                 .setDescription(reason));
 351         }
 352
 353         /**
 354          * Create a new version of a document in the given study step.
 355          *
 356          * @param aStep
 357          *            the study step
 358          * @param base
 359          *            the base document published version
 360          * @param dprop
 361          *            properties of the new version
 362          * @return the new version publication
 363          * @throws MissedPropertyException
 364          *             if a mandatory property is missed
 365          * @throws InvalidPropertyException
 366          *             if some property doesn't exist
 367          * @throws MultiplyDefinedException
 368          *             if some property is defined several times
 369          * @throws IOException
 370          *             if a file system error occurs
 371          * @throws MismatchException
 372          *             if the document is not applicable to the given study step
 373          */
 374         @Transactional
 375         public Publication versionDocument(final Step aStep,
 376                         final Publication base, final Document.Properties dprop)
 377                         throws MissedPropertyException, InvalidPropertyException,
 378                         MultiplyDefinedException, IOException, MismatchException {
 379                 Document previous = base.value();
 380
 381                 // RKV: Keep the new file format if it is related to the same document type on this step.
 382                 String newFormat = dprop.getFormat();
 383
 384                 dprop.setDocument(previous, getProjectSettings().getStep(
 385                                 base.getStep().getNumber())); // Initializes the Step property
 386                 if (dprop.getStep().getNumber() != aStep.getNumber()) {
 387                         throw new MismatchException();
 388                 }
 389
 390                 if (newFormat != null
 391                 /*
 392                  * && previous.getType().equals( getProjectSettings().getDefaultDocumentType( aStep.getStep(), newFormat))
 393                  */) {
 394                         dprop.setFormat(newFormat);
 395                 }
 396
 397                 if (dprop.getAuthor() == null) {
 398                         dprop.setAuthor(previous.getAuthor());
 399                 }
 400                 String summary = dprop.getDescription();
 401
 402                 // Creation of the document
 403                 Document newdoc = new Document(dprop.setOwner(aStep.getOwner())
 404                                 .setStep(aStep.getStep()));
 405                 getDocumentService().generateDocumentId(newdoc, dprop);
 406                 getDocumentService().buildReferenceFrom(newdoc, aStep.getOwner(),
 407                                 previous);
 408                 getDocumentDAO().create(newdoc);
 409
 410                 // Versioning
 411                 VersionsRelation aRel;
 412                 aRel = new VersionsRelation(newdoc, previous, summary);
 413                 // getVersionsRelationDAO().create(aRel);
 414                 newdoc.addRelation(aRel);
 415
 416                 // Update of usedby relations, if exist
 417                 /*
 418                  * RKV: Consider the new version as not used by old dependent documents. So these documents must be marked as outdated then. List<Relation>
 419                  * relist = previous.getRelations(UsedByRelation.class); Study scope = aStep.getOwnerStudy(); for (Iterator<Relation> i =
 420                  * relist.iterator(); i.hasNext();) { UsedByRelation relation = (UsedByRelation) i.next(); Document relatedoc = relation.getTo(); if
 421                  * (scope.shares(relatedoc)) { relatedoc.addRelation(new UsesRelation(relatedoc, newdoc)); } else { relation.moveTo(newdoc); } }
 422                  */
 423                 return new Publication(newdoc, aStep.getOwner());
 424         }
 425
 426         /**
 427          * Get document types which are applicable for the given study step (activity).
 428          *
 429          * @param aStep
 430          *            the study step
 431          * @return the list of document types
 432          */
 433         @Override
 434         public List<DocumentType> getValidDocumentTypes(final Step aStep) {
 435                 return getDocumentTypeService().selectTypesOf(aStep.getStep());
 436         }
 437
 438         /**
 439          * Add a document publication to the given step.
 440          *
 441          * @param aStep
 442          *            the target study step
 443          * @param newdoc
 444          *            the document publication to add
 445          * @return true if publication succeeded
 446          */
 447         @Override
 448         public boolean add(final Step aStep, final Publication newdoc) {
 449                 boolean res = aStep.getOwner().add(newdoc); // Updates the study in memory
 450                 if (res) {
 451                         aStep.getDocuments().add(0, newdoc); // Updates this step
 452                         getDocumentService().hold(newdoc.value()); // Increments the configuration tag count of document
 453                         // If not yet saved, the Publication MUST NOT be saved here, although this creates a temporary inconsistent state into the
 454                         // database (it will be saved later by cascading the update of owner scenario).
 455                 }
 456                 return res;
 457         }
 458
 459         /**
 460          * Remove a document publication from the given step.
 461          *
 462          * @param aStep
 463          *            the study step
 464          * @param oldoc
 465          *            the document publication to remove
 466          * @return true if removing of the publication succeeded
 467          */
 468         @Override
 469         public boolean remove(final Step aStep, final Publication oldoc) {
 470                 aStep.getDocuments().remove(oldoc); // Updates this step
 471                 aStep.getOwner().remove(oldoc); // remove from the parent project element
 472                 getProjectElementDAO().merge(aStep.getOwner().getOwnerStudy());
 473                 getDocumentService().release(oldoc.value()); // Decrements the configuration tag count of document
 474                 // The publication becoming orphan, it should automatically be removed from the database when updating of owner scenario.
 475                 return true;
 476         }
 477
 478         /**
 479          * Remove a document from the given step and from the database if it is no more used.
 480          *
 481          * @param aStep
 482          *            the study step
 483          * @param docId
 484          *            the document id
 485          * @return true if removing of the document succeeded
 486          * @throws DocumentIsUsedException
 487          *             if the document is used by other documents
 488          */
 489         @Override
 490         @Transactional
 491         public boolean removeDocument(final Step aStep, final long docId)
 492                         throws DocumentIsUsedException {
 493                 Publication torem = aStep.getDocument(docId);
 494                 boolean res = (torem != null);
 495                 if (res) {
 496                         if (!torem.value().getRelations(UsedByRelation.class).isEmpty()) {
 497                                 throw new DocumentIsUsedException(torem.value().getTitle());
 498                         }
 499                         remove(aStep, torem);
 500                         Document value = torem.value();
 501                         if (!value.isPublished() && !value.isVersioned()) { // The referenced document is no more used
 502                                 List<Document> using = new ArrayList<Document>();
 503                                 List<File> files = new ArrayList<File>();
 504                                 for (Relation link : value.getAllRelations()) {
 505                                         if (link.getClass().equals(ConvertsRelation.class)) { // File conversion
 506                                                 files.add((File) link.getTo());
 507                                         } else if (link.getClass().equals(UsesRelation.class)) { // Document dependency
 508                                                 using.add((Document) link.getTo());
 509                                         }
 510                                 }
 511                                 // Remove relations from depending documents
 512                                 if (LOG.isDebugEnabled()) {
 513                                         LOG.debug("Remove " + using.size() + " UsedByRelation(s).");
 514                                 }
 515                                 for (Document doc : using) {
 516                                         if (LOG.isDebugEnabled()) {
 517                                                 LOG.debug("Remove UsedByRelation from "
 518                                                                 + doc.getTitle() + " to " + value.getTitle());
 519                                                 LOG.debug("Nb relations of doc " + doc.getTitle()
 520                                                                 + " before: " + doc.getAllRelations().size());
 521                                         }
 522                                         doc.removeRelation(UsedByRelation.class, value);
 523                                         if (LOG.isDebugEnabled()) {
 524                                                 LOG.debug("Nb relations of doc " + doc.getTitle()
 525                                                                 + " after: " + doc.getAllRelations().size());
 526                                         }
 527                                         getDocumentDAO().merge(doc);
 528                                 }
 529                                 // Synchronize deleted objects with the database to avoid hibernate exception
 530                                 // org.hibernate.PropertyValueException: not-null property references a null or transient value
 531                                 getDocumentDAO().flush();
 532                                 // The corresponding physical file is not removed from the vault
 533                                 getDocumentDAO().delete(getDocumentDAO().merge(torem.value()));
 534                                 // Delete document's files
 535                                 //TODO: delete files from file system
 536 //                              for (File file : files) {
 537 //                                      getFileDAO().delete(getFileDAO().merge(file)); // The corresponding physical file is not removed from the vault
 538 //                              }
 539                         }
 540                 }
 541                 return res;
 542         }
 543
 544         /**
 545          * {@inheritDoc}
 546          *
 547          * @see org.splat.service.StepService#addComment(org.splat.som.Step, org.splat.dal.bo.som.CommentAttribute)
 548          */
 549         @Override
 550         @Transactional
 551         public void addStepComment(final StepCommentDTO comment)
 552                         throws InvalidParameterException {
 553
 554                 if (comment.getId() != null) {
 555                         throw new InvalidParameterException("id", String.valueOf(comment
 556                                         .getId()));
 557                 }
 558                 User user = getUserDAO().get(comment.getUserId());
 559                 if (user == null) {
 560                         throw new InvalidParameterException("userId", String
 561                                         .valueOf(comment.getUserId()));
 562                 }
 563                 ProjectElement projectElement = getProjectElementDAO().get(
 564                                 comment.getProjectElementId());
 565                 if (projectElement == null) {
 566                         throw new InvalidParameterException("projectElementId", comment
 567                                         .getProjectElementId().toString());
 568                 }
 569                 if (comment.getStep() == null || comment.getStep() < 0) {
 570                         throw new InvalidParameterException("step", String.valueOf(comment
 571                                         .getStep()));
 572                 }
 573                 if (comment.getDate() == null) {
 574                         throw new InvalidParameterException("date", String.valueOf(comment
 575                                         .getDate()));
 576                 }
 577                 if (comment.getTitle() == null) {
 578                         throw new InvalidParameterException("title", String.valueOf(comment
 579                                         .getTitle()));
 580                 }
 581
 582                 StepCommentAttribute newComment = new StepCommentAttribute(
 583                                 projectElement, comment.getText(), comment.getDate(), comment
 584                                                 .getStep(), user, comment.getTitle());
 585
 586                 Long resultKey = getStepCommentAttributeDAO().create(newComment);
 587                 comment.setId(resultKey);
 588         }
 589
 590         /**
 591          * {@inheritDoc}
 592          *
 593          * @see org.splat.service.StepService#getStepComments(org.splat.som.Step)
 594          */
 595         @Override
 596         @Transactional(readOnly = true)
 597         public List<StepCommentDTO> getStepComments(final Step step)
 598                         throws InvalidParameterException {
 599                 ProjectElement owner = _projectElementDAO.get(step.getOwner().getRid());
 600                 if (owner == null) {
 601                         throw new InvalidParameterException("step owner id", Long.valueOf(
 602                                         step.getOwner().getRid()).toString());
 603                 }
 604                 List<StepCommentAttribute> comments = _stepCommentAttributeDAO
 605                                 .getFilteredList(Restrictions.and(Restrictions.eq("step",
 606                                                 Integer.valueOf(step.getNumber())), Restrictions.eq(
 607                                                 "owner", owner)));
 608                 List<StepCommentDTO> commentDTOs = new ArrayList<StepCommentDTO>();
 609                 for (StepCommentAttribute comment : comments) {
 610                         StepCommentDTO stepCommentDTO = BeanHelper.copyBean(comment,
 611                                         StepCommentDTO.class);
 612                         stepCommentDTO.setText(comment.getValue());
 613                         stepCommentDTO.setId(Long.valueOf(comment.getRid()));
 614                         commentDTOs.add(stepCommentDTO);
 615                 }
 616                 return commentDTOs;
 617         }
 618
 619         /**
 620          * {@inheritDoc}
 621          *
 622          * @see org.splat.service.StepService#removeStepComment(long)
 623          */
 624         @Override
 625         @Transactional
 626         public void removeStepComment(final long commentId)
 627                         throws InvalidParameterException {
 628                 StepCommentAttribute stepComment = _stepCommentAttributeDAO.get(Long
 629                                 .valueOf(commentId));
 630                 if (stepComment == null) {
 631                         throw new InvalidParameterException("commentId", String
 632                                         .valueOf(commentId));
 633                 }
 634                 _stepCommentAttributeDAO.delete(stepComment);
 635         }
 636
 637         /**
 638          * {@inheritDoc}
 639          *
 640          * @see org.splat.service.StepService#editStepComment(long, java.lang.String, java.lang.String)
 641          */
 642         @Override
 643         @Transactional
 644         public void editStepComment(final long commentId, final String newValue,
 645                         final String newTitle) throws InvalidParameterException {
 646                 StepCommentAttribute comment = _stepCommentAttributeDAO.get(Long
 647                                 .valueOf(commentId));
 648                 if (comment == null) {
 649                         throw new InvalidParameterException("commentId", String
 650                                         .valueOf(commentId));
 651                 }
 652                 if (newTitle != null) {
 653                         comment.setTitle(newTitle);
 654                 }
 655                 if (newValue != null) {
 656                         comment.setValue(newValue);
 657                 }
 658                 _stepCommentAttributeDAO.update(comment);
 659         }
 660
 661         /**
 662          * {@inheritDoc}
 663          *
 664          * @see org.splat.service.StepService#isCommentMadeByUser(long, long)
 665          */
 666         @Override
 667         @Transactional(readOnly = true)
 668         public boolean isCommentMadeByUser(final long commentId, final long userId)
 669                         throws InvalidParameterException {
 670                 StepCommentAttribute comment = _stepCommentAttributeDAO.get(Long
 671                                 .valueOf(commentId));
 672                 if (comment == null) {
 673                         throw new InvalidParameterException("commentId", String
 674                                         .valueOf(commentId));
 675                 }
 676                 return comment.getUser().getIndex() == userId;
 677         }
 678
 679         /**
 680          * Get the documentService.
 681          *
 682          * @return the documentService
 683          */
 684         public DocumentService getDocumentService() {
 685                 return _documentService;
 686         }
 687
 688         /**
 689          * Set the documentService.
 690          *
 691          * @param documentService
 692          *            the documentService to set
 693          */
 694         public void setDocumentService(final DocumentService documentService) {
 695                 _documentService = documentService;
 696         }
 697
 698         /**
 699          * Get the simulationContextService.
 700          *
 701          * @return the simulationContextService
 702          */
 703         public SimulationContextService getSimulationContextService() {
 704                 return _simulationContextService;
 705         }
 706
 707         /**
 708          * Set the simulationContextService.
 709          *
 710          * @param simulationContextService
 711          *            the simulationContextService to set
 712          */
 713         public void setSimulationContextService(
 714                         final SimulationContextService simulationContextService) {
 715                 _simulationContextService = simulationContextService;
 716         }
 717
 718         /**
 719          * Get the documentDAO.
 720          *
 721          * @return the documentDAO
 722          */
 723         public DocumentDAO getDocumentDAO() {
 724                 return _documentDAO;
 725         }
 726
 727         /**
 728          * Set the documentDAO.
 729          *
 730          * @param documentDAO
 731          *            the documentDAO to set
 732          */
 733         public void setDocumentDAO(final DocumentDAO documentDAO) {
 734                 _documentDAO = documentDAO;
 735         }
 736
 737         /**
 738          * Get the simulationContextDAO.
 739          *
 740          * @return the simulationContextDAO
 741          */
 742         public SimulationContextDAO getSimulationContextDAO() {
 743                 return _simulationContextDAO;
 744         }
 745
 746         /**
 747          * Set the simulationContextDAO.
 748          *
 749          * @param simulationContextDAO
 750          *            the simulationContextDAO to set
 751          */
 752         public void setSimulationContextDAO(
 753                         final SimulationContextDAO simulationContextDAO) {
 754                 _simulationContextDAO = simulationContextDAO;
 755         }
 756
 757         /**
 758          * Get the projectElementDAO.
 759          *
 760          * @return the projectElementDAO
 761          */
 762         public ProjectElementDAO getProjectElementDAO() {
 763                 return _projectElementDAO;
 764         }
 765
 766         /**
 767          * Set the projectElementDAO.
 768          *
 769          * @param projectElementDAO
 770          *            the projectElementDAO to set
 771          */
 772         public void setProjectElementDAO(final ProjectElementDAO projectElementDAO) {
 773                 _projectElementDAO = projectElementDAO;
 774         }
 775
 776         /**
 777          * Get the indexService.
 778          *
 779          * @return the indexService
 780          */
 781         public IndexService getIndexService() {
 782                 return _indexService;
 783         }
 784
 785         /**
 786          * Set the indexService.
 787          *
 788          * @param indexService
 789          *            the indexService to set
 790          */
 791         public void setIndexService(final IndexService indexService) {
 792                 _indexService = indexService;
 793         }
 794
 795         /**
 796          * Get the fileDAO.
 797          *
 798          * @return the fileDAO
 799          */
 800         public FileDAO getFileDAO() {
 801                 return _fileDAO;
 802         }
 803
 804         /**
 805          * Set the fileDAO.
 806          *
 807          * @param fileDAO
 808          *            the fileDAO to set
 809          */
 810         public void setFileDAO(final FileDAO fileDAO) {
 811                 _fileDAO = fileDAO;
 812         }
 813
 814         /**
 815          * Get the documentTypeService.
 816          *
 817          * @return the documentTypeService
 818          */
 819         public DocumentTypeService getDocumentTypeService() {
 820                 return _documentTypeService;
 821         }
 822
 823         /**
 824          * Set the documentTypeService.
 825          *
 826          * @param documentTypeService
 827          *            the documentTypeService to set
 828          */
 829         public void setDocumentTypeService(
 830                         final DocumentTypeService documentTypeService) {
 831                 _documentTypeService = documentTypeService;
 832         }
 833
 834         /**
 835          * Get the versionsRelationDAO.
 836          *
 837          * @return the versionsRelationDAO
 838          */
 839         public VersionsRelationDAO getVersionsRelationDAO() {
 840                 return _versionsRelationDAO;
 841         }
 842
 843         /**
 844          * Set the versionsRelationDAO.
 845          *
 846          * @param versionsRelationDAO
 847          *            the versionsRelationDAO to set
 848          */
 849         public void setVersionsRelationDAO(
 850                         final VersionsRelationDAO versionsRelationDAO) {
 851                 _versionsRelationDAO = versionsRelationDAO;
 852         }
 853
 854         /**
 855          * Get project settings.
 856          *
 857          * @return Project settings service
 858          */
 859         private ProjectSettingsService getProjectSettings() {
 860                 return _projectSettings;
 861         }
 862
 863         /**
 864          * Set project settings service.
 865          *
 866          * @param projectSettingsService
 867          *            project settings service
 868          */
 869         public void setProjectSettings(
 870                         final ProjectSettingsService projectSettingsService) {
 871                 _projectSettings = projectSettingsService;
 872         }
 873
 874         /**
 875          * Get the stepCommentAttributeDAO.
 876          *
 877          * @return the stepCommentAttributeDAO
 878          */
 879         public StepCommentAttributeDAO getStepCommentAttributeDAO() {
 880                 return _stepCommentAttributeDAO;
 881         }
 882
 883         /**
 884          * Set the stepCommentAttributeDAO.
 885          *
 886          * @param commentAttributeDAO
 887          *            the stepCommentAttributeDAO to set
 888          */
 889         public void setStepCommentAttributeDAO(
 890                         final StepCommentAttributeDAO commentAttributeDAO) {
 891                 _stepCommentAttributeDAO = commentAttributeDAO;
 892         }
 893
 894         /**
 895          * Get the userDAO.
 896          *
 897          * @return the userDAO
 898          */
 899         public UserDAO getUserDAO() {
 900                 return _userDAO;
 901         }
 902
 903         /**
 904          * Set the userDAO.
 905          *
 906          * @param userDAO
 907          *            the userDAO to set
 908          */
 909         public void setUserDAO(final UserDAO userDAO) {
 910                 _userDAO = userDAO;
 911         }
 912
 913         /**
 914          * Get the publicationDAO.
 915          *
 916          * @return the publicationDAO
 917          */
 918         public PublicationDAO getPublicationDAO() {
 919                 return _publicationDAO;
 920         }
 921
 922         /**
 923          * Set the publicationDAO.
 924          *
 925          * @param publicationDAO
 926          *            the publicationDAO to set
 927          */
 928         public void setPublicationDAO(final PublicationDAO publicationDAO) {
 929                 this._publicationDAO = publicationDAO;
 930         }
 931
 932         /**
 933          * Get the relationDAO.
 934          *
 935          * @return the relationDAO
 936          */
 937         public RelationDAO getRelationDAO() {
 938                 return _relationDAO;
 939         }
 940
 941         /**
 942          * Set the relationDAO.
 943          *
 944          * @param relationDAO
 945          *            the relationDAO to set
 946          */
 947         public void setRelationDAO(final RelationDAO relationDAO) {
 948                 _relationDAO = relationDAO;
 949         }
 950 }