Workspace/Siman-Common/src/org/splat/som/DocumentRights.java

   1 package org.splat.som;
   2
   3 /**
   4  * Class providing services for checking the rights related to operations on a given document. These rights are partially driven by the
   5  * validation cycle associated to documents.
   6  *
   7  * @see ValidationCycle
   8  * @author Daniel Brunier-Coulin
   9  * @copyright OPEN CASCADE 2012
  10  */
  11 // TODO: Review this rights in the following contexts:
  12 // - Document shared by several scenarios
  13 // - Document out-dated following a modification of a document it uses
  14 import java.util.Iterator;
  15 import java.util.List;
  16
  17 import org.splat.dal.bo.kernel.Relation;
  18 import org.splat.dal.bo.kernel.User;
  19 import org.splat.dal.bo.som.Document;
  20 import org.splat.dal.bo.som.ProgressState;
  21 import org.splat.dal.bo.som.Publication;
  22 import org.splat.dal.bo.som.UsedByRelation;
  23 import org.splat.dal.bo.som.UsesRelation;
  24 import org.splat.dal.bo.som.ValidationCycle;
  25 import org.splat.dal.bo.som.ValidationStep;
  26 import org.splat.dal.bo.som.VersionsRelation;
  27 import org.splat.service.ServiceLocatorImpl;
  28 import org.splat.service.StudyService;
  29
  30 /**
  31  * The class defining user rights to the document.
  32  */
  33 public class DocumentRights {
  34
  35         /**
  36          * The connected user.
  37          */
  38         private transient final User _user;
  39         /**
  40          * The document publication.
  41          */
  42         private transient Publication _operand;
  43         /**
  44          * The document validation cycle.
  45          */
  46         private transient final ValidationCycle _cycle;
  47         /**
  48          * True if the user is author of the document.
  49          */
  50         private final transient boolean _isauthor;
  51
  52         // ==============================================================================================================================
  53         // Constructors
  54         // ==============================================================================================================================
  55
  56         /**
  57          * The constructor.
  58          *
  59          * @param user
  60          *            the current user
  61          * @param tag
  62          *            the document publication
  63          */
  64         public DocumentRights(final User user, final Publication tag) {
  65                 this._user = user;
  66                 this._operand = tag;
  67                 // RKV this.cycle = operand.getOwnerStudy().getValidationCycleOf(operand.value().getType());
  68                 this._cycle = getStudyService().getValidationCycleOf(
  69                                 _operand.getOwnerStudy(), _operand.value().getType());
  70                 this._isauthor = _operand.value().getAuthor().equals(user);
  71                 // TODO: all contributors of the given document (when supported) must also behave as author
  72         }
  73
  74         /**
  75          * The constructor in the case when the user is an author of the document.
  76          *
  77          * @param tag
  78          *            the document publication
  79          */
  80         protected DocumentRights(final Publication tag) {
  81                 this._operand = tag;
  82                 this._user = _operand.value().getAuthor();
  83                 this._operand = tag;
  84                 this._cycle = getStudyService().getValidationCycleOf(
  85                                 _operand.getOwnerStudy(), _operand.value().getType());
  86                 this._isauthor = true; // In order to ignore the author state in the context of any user
  87                 // TODO: all contributors of the given document (when supported) must also behave as author
  88         }
  89
  90         // ==============================================================================================================================
  91         // Public member functions
  92         // ==============================================================================================================================
  93
  94         /**
  95          * Checks if the user has right to accept the modifications of documents depending on the selected document. This operation applies to
  96          * out-dated documents following a modification of documents they use. Only the author of the document has such right.
  97          *
  98          * @return true if the user has right to accept the modifications of dependencies of the document.
  99          * @see Publication#accept()
 100          */
 101         public boolean canAccept() {
 102                 return _isauthor && _operand.isOutdated();
 103         }
 104
 105         /**
 106          * Checks if the user has right to approve the selected document. Only the approver of the type of selected document has such right,
 107          * providing that the document is candidate for approval and all document dependencies have already been approved.
 108          *
 109          * @return true if the user has right to approve the document.
 110          * @see Publication#approve()
 111          * @see ValidationCycle
 112          */
 113         public boolean canApprove() {
 114                 User approver = _cycle.getActor(ValidationStep.APPROVAL); // May be null if not approvable
 115                 boolean res = (_user.equals(approver))
 116                                 && (_operand.getProgressState() == ProgressState.inCHECK);
 117                 if (res) {
 118                         List<Relation> use = _operand.value().getRelations(
 119                                         UsesRelation.class);
 120                         for (Iterator<Relation> i = use.iterator(); i.hasNext();) {
 121                                 Document depend = (Document) i.next().getTo();
 122                                 ProgressState state = depend.getProgressState();
 123                                 if (state == ProgressState.EXTERN) {
 124                                         continue; // External documents do not follow this progress state
 125                                 }
 126                                 if (state != ProgressState.APPROVED) {
 127                                         res = false;
 128                                         break;
 129                                 }
 130                         }
 131                 }
 132                 return res;
 133         }
 134
 135         /**
 136          * Checks if the user has right to attach a file to the selected document. Both, the author, during the elaboration of the document, and
 137          * the reviewer of the document, during the review process, have such right.
 138          *
 139          * @return true if the user has right to attach a file to the document.
 140          * @see Publication#attach(String)
 141          * @see Publication#attach(String, String)
 142          */
 143         public boolean canAttach() {
 144                 User manager = _operand.getOwnerStudy().getAuthor();
 145                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 146                 ProgressState state = _operand.value().getProgressState();
 147
 148                 return _isauthor
 149                                 || ((state != ProgressState.inWORK) && (_user.equals(manager) || _user
 150                                                 .equals(reviewer)));
 151         }
 152
 153         /**
 154          * Checks if the user has right to demote the selected document. A document can be demoted providing that it is In-Draft or In-Check and
 155          * all documents using it have previously been demoted. In-Draft documents can be demoted by default by both, the author of the document
 156          * and the responsible of study, while documents in approval process can be demoted by their approver only.
 157          *
 158          * @return true if the user has right to demote the document.
 159          * @see #canInvalidate()
 160          * @see #canPromote()
 161          * @see Publication#demote()
 162          * @see ValidationCycle
 163          */
 164         public boolean canDemote() {
 165                 User manager = _operand.getOwnerStudy().getAuthor();
 166                 User publisher = _cycle.getActor(ValidationStep.PROMOTION); // Null if the default users are involved
 167                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 168                 User approver = _cycle.getActor(ValidationStep.APPROVAL); // May be null if not approvable
 169                 ProgressState mystate = _operand.value().getProgressState();
 170
 171                 boolean res = (mystate == ProgressState.inDRAFT
 172                                 && (_user.equals(publisher) || _user.equals(reviewer)
 173                                                 || _user.equals(manager) || (reviewer == null)
 174                                                 && _user.equals(approver)) || mystate == ProgressState.inCHECK
 175                                 && (_user.equals(approver) || _user.equals(reviewer) || (reviewer == null)
 176                                                 && (_user.equals(publisher) || _user.equals(manager))));
 177
 178                 if (res) {
 179                         List<Relation> use = _operand.value().getRelations(
 180                                         UsedByRelation.class);
 181                         for (Relation rel : use) {
 182                                 Document depend = (Document) rel.getTo();
 183                                 ProgressState state = depend.getProgressState();
 184                                 if (((mystate == ProgressState.inDRAFT) || (mystate == ProgressState.inCHECK && (state != ProgressState.inDRAFT)))
 185                                                 && state != ProgressState.inWORK) {
 186                                         res = false;
 187                                         break;
 188                                 }
 189                         }
 190                 }
 191                 return res;
 192         }
 193
 194         /**
 195          * Checks if the user has right to check-out the selected document for editing. In-Work documents can be checked-out by both, the author
 196          * of the document and the responsible of study, while documents In-Draft can be checked-out by the reviewer only.
 197          *
 198          * @return true if the user has right to edit the document.
 199          */
 200         public boolean canEdit() {
 201                 User manager = _operand.getOwnerStudy().getAuthor();
 202                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 203                 ProgressState state = _operand.value().getProgressState();
 204
 205                 // TODO: Should be restricted by the application if no editor available
 206                 if (state == ProgressState.inWORK) {
 207                         if (_isauthor || _user.equals(manager)) {
 208                                 return true;
 209                         }
 210                 } else if (state == ProgressState.inDRAFT) {
 211                         if (_user.equals(reviewer)) {
 212                                 return true;
 213                         }
 214                 }
 215                 return false;
 216         }
 217
 218         /**
 219          * Checks if the user has right to promote the selected document. A document can be promoted providing that it is In-Work and all its
 220          * dependencies have previously been promoted. By default, both the author of the document and the responsible of study has right to
 221          * promote such document. Otherwise, only the user involved in the Promotion step of validation cycle of the selected document has such
 222          * right.
 223          *
 224          * @return true if the user has right to promote the document.
 225          * @see #canDemote()
 226          * @see Publication#promote()
 227          * @see ValidationCycle
 228          */
 229         public boolean canPromote() {
 230                 User manager = _operand.getOwnerStudy().getAuthor();
 231                 User publisher = _cycle.getActor(ValidationStep.PROMOTION); // Null if the default users are involved
 232
 233                 if (_operand.getProgressState() != ProgressState.inWORK) {
 234                         if (_operand.getProgressState() == ProgressState.inDRAFT) {
 235                                 return canReview();
 236                         }
 237                         return false;
 238                 }
 239                 if (publisher == null) {
 240                         if (!_isauthor && !_user.equals(manager)) {
 241                                 return false;
 242                         }
 243                 } else {
 244                         if (!_user.equals(publisher)) {
 245                                 return false;
 246                         }
 247                 }
 248                 List<Relation> use = _operand.value().getRelations(UsesRelation.class);
 249                 for (Iterator<Relation> i = use.iterator(); i.hasNext();) {
 250                         Document depend = (Document) i.next().getTo();
 251                         ProgressState state = depend.getProgressState();
 252                         if (state == ProgressState.EXTERN) {
 253                                 continue; // External documents do not follow this progress state
 254                         }
 255                         if (state == ProgressState.inWORK) {
 256                                 return false;
 257                         }
 258                 }
 259                 return true;
 260         }
 261
 262         /**
 263          * Checks if the user has right to remove the history of the selected document, if exists. Only the responsible of the study have such
 264          * right.
 265          *
 266          * @return true if the user has right to purge the document.
 267          */
 268         public boolean canPurge() {
 269                 User manager = _operand.getOwnerStudy().getAuthor();
 270                 Document doc = _operand.value();
 271
 272                 if (!_user.equals(manager)) {
 273                         return false;
 274                 }
 275                 if (doc.isShared()) {
 276                         return false;
 277                 }
 278                 if (doc.getFirstRelation(VersionsRelation.class) == null) {
 279                         return false;
 280                 }
 281                 return true;
 282         }
 283
 284         /**
 285          * Checks if the user has right to remove the selected document from the study. Both, the author of the document and the responsible of
 286          * the study, have such right, providing that: - the document is neither in review or in approval process - the document is not used by
 287          * any other document
 288          *
 289          * @return true if the user has right to remove the document.
 290          * @see Step#removeDocument(Publication)
 291          */
 292         public boolean canRemove() {
 293                 User manager = _operand.getOwnerStudy().getAuthor();
 294                 ProgressState state = _operand.getProgressState();
 295
 296                 if (!_isauthor && !_user.equals(manager)) {
 297                         return false;
 298                 }
 299                 if (state != ProgressState.inWORK && state != ProgressState.EXTERN) {
 300                         return false;
 301                 }
 302
 303                 List<Relation> using = _operand.value().getRelations(
 304                                 UsedByRelation.class);
 305                 return using.isEmpty();
 306         }
 307
 308         /**
 309          * Checks if the user has right to rename the selected document. Only the author of the document has such right, providing that the
 310          * document is neither in review nor in approval process.
 311          *
 312          * @return true if the user has right to rename the document.
 313          * @see Publication#rename(String)
 314          */
 315         public boolean canRename() {
 316                 ProgressState state = _operand.getProgressState();
 317
 318                 if (!_isauthor) {
 319                         return false; // In case of external document, the author is the one who has imported the document.
 320                 }
 321                 if (state != ProgressState.inWORK && state != ProgressState.EXTERN) {
 322                         return false;
 323                 }
 324                 return (!_operand.value().isShared());
 325         }
 326
 327         /**
 328          * Checks if the user has right to replace the source file of the selected document. Both, the author of the document and the
 329          * responsible of study has such right, providing that the document is neither in review nor in approval process.
 330          *
 331          * @return true if the user has right to replace the document.
 332          */
 333         public boolean canReplace() {
 334                 User manager = _operand.getOwnerStudy().getAuthor();
 335                 ProgressState state = _operand.getProgressState();
 336
 337                 if (!_isauthor && !_user.equals(manager)) {
 338                         return false; // Supposed to work also in case of external document.
 339                 }
 340                 if (state != ProgressState.inWORK && state != ProgressState.EXTERN) {
 341                         return false;
 342                 }
 343                 return !_operand.value().isShared();
 344         }
 345
 346         /**
 347          * Checks if the user has right to validate the selected document. Only the reviewer of the type of selected document has such right,
 348          * providing that the document is being reviewed and all document dependencies have already been validated.
 349          *
 350          * @return true if the user has right to validate the document
 351          * @see #canUnvalidate()
 352          * @see Publication#review()
 353          * @see ValidationCycle
 354          */
 355         public boolean canReview() {
 356                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 357
 358                 if (!_user.equals(reviewer)) {
 359                         return false;
 360                 }
 361                 if (_operand.getProgressState() != ProgressState.inDRAFT) {
 362                         return false;
 363                 }
 364
 365                 List<Relation> use = _operand.value().getRelations(UsesRelation.class);
 366                 for (Iterator<Relation> i = use.iterator(); i.hasNext();) {
 367                         Document depend = (Document) i.next().getTo();
 368                         ProgressState state = depend.getProgressState();
 369                         if (state == ProgressState.EXTERN) {
 370                                 continue; // External documents do not follow this progress state
 371                         }
 372                         if (state == ProgressState.inWORK || state == ProgressState.inDRAFT) {
 373                                 return false;
 374                         }
 375                 }
 376                 return true;
 377         }
 378
 379         /**
 380          * Checks if the user has right to undo the validation operation of the selected document. Both, the author and the reviewer of a
 381          * validated document, have such right.
 382          *
 383          * @return true if the user has right to undo the validation operation
 384          * @see #canDemote()
 385          * @see #canReview()
 386          * @see Publication#invalidate()
 387          * @see ValidationCycle
 388          */
 389         public boolean canInvalidate() {
 390                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 391                 ProgressState mystate = _operand.value().getProgressState();
 392
 393                 if (mystate != ProgressState.inCHECK) {
 394                         return false;
 395                 }
 396                 if (!_isauthor && !_user.equals(reviewer)) {
 397                         return false;
 398                 }
 399
 400                 List<Relation> use = _operand.value()
 401                                 .getRelations(UsedByRelation.class);
 402                 for (Iterator<Relation> i = use.iterator(); i.hasNext();) {
 403                         Document depend = (Document) i.next().getTo();
 404                         ProgressState state = depend.getProgressState();
 405                         if (mystate == ProgressState.inDRAFT
 406                                         && state != ProgressState.inWORK) {
 407                                 return false;
 408                         }
 409                         if (mystate == ProgressState.inCHECK
 410                                         && (state != ProgressState.inDRAFT && state != ProgressState.inWORK)) {
 411                                 return false;
 412                         }
 413                 }
 414                 return true;
 415         }
 416
 417         /**
 418          * Checks if the user has right to version the selected document. In-Work documents can be versioned by both, the author of the document
 419          * and the responsible of study, while documents In-Draft can be versioned by the reviewer only. Additionally, Approved documents can
 420          * also be versioned by their author in order to enter in a new modification validation cycle.
 421          *
 422          * @return true if the user has right to version the document.
 423          * @see Step#versionDocument(Publication)
 424          * @see Step#versionDocument(Publication, Document.Properties)
 425          * @see Step#versionDocument(Publication, String)
 426          */
 427         public boolean canVersion() {
 428                 User manager = _operand.getOwnerStudy().getAuthor();
 429                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 430                 ProgressState state = _operand.value().getProgressState();
 431
 432                 if (state == ProgressState.inWORK) {
 433                         if (_isauthor || _user.equals(manager)) {
 434                                 return true;
 435                         }
 436                 } else if (state == ProgressState.inDRAFT) {
 437                         if (_user.equals(reviewer)) {
 438                                 return true;
 439                         }
 440                 } else if (state == ProgressState.APPROVED) {
 441                         if (_isauthor) {
 442                                 return true;
 443                         }
 444
 445                 } else if (state == ProgressState.EXTERN) {
 446                         if (_isauthor || _user.equals(manager)) {
 447                                 return true;
 448                         }
 449                 }
 450
 451                 return false;
 452         }
 453
 454         // ==============================================================================================================================
 455         // Getter
 456         // ==============================================================================================================================
 457
 458         /**
 459          * Returns the document subject of checks according to this user rights.
 460          *
 461          * @return the document subject of checks.
 462          */
 463         public Document getOperand() {
 464                 return _operand.value();
 465         }
 466
 467         /**
 468          * Get the study service.
 469          *
 470          * @return the study service
 471          */
 472         private StudyService getStudyService() {
 473                 return ServiceLocatorImpl.getInstance().getStudyService();
 474         }
 475 }