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                 if (mystate == ProgressState.inDRAFT) {
 172                         if (publisher == null) {
 173                                 if ((!_isauthor) && (!_user.equals(manager))
 174                                                 && (!_user.equals(reviewer))) {
 175                                         return false;
 176                                 }
 177                         } else if ((!_user.equals(publisher)) && (!_user.equals(reviewer))) {
 178                                 return false;
 179                         }
 180                 } else if (mystate == ProgressState.inCHECK) {
 181                         if (!_user.equals(approver)) {
 182                                 return false;
 183                         }
 184                 } else {
 185                         return false;
 186                 }
 187
 188                 List<Relation> use = _operand.value()
 189                                 .getRelations(UsedByRelation.class);
 190                 for (Iterator<Relation> i = use.iterator(); i.hasNext();) {
 191                         Document depend = (Document) i.next().getTo();
 192                         ProgressState state = depend.getProgressState();
 193                         if (mystate == ProgressState.inDRAFT
 194                                         && state != ProgressState.inWORK) {
 195                                 return false;
 196                         }
 197                         if (mystate == ProgressState.inCHECK
 198                                         && (state != ProgressState.inDRAFT && state != ProgressState.inWORK)) {
 199                                 return false;
 200                         }
 201                 }
 202                 return true;
 203         }
 204
 205         /**
 206          * 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
 207          * of the document and the responsible of study, while documents In-Draft can be checked-out by the reviewer only.
 208          *
 209          * @return true if the user has right to edit the document.
 210          */
 211         public boolean canEdit() {
 212                 User manager = _operand.getOwnerStudy().getAuthor();
 213                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 214                 ProgressState state = _operand.value().getProgressState();
 215
 216                 // TODO: Should be restricted by the application if no editor available
 217                 if (state == ProgressState.inWORK) {
 218                         if (_isauthor || _user.equals(manager)) {
 219                                 return true;
 220                         }
 221                 } else if (state == ProgressState.inDRAFT) {
 222                         if (_user.equals(reviewer)) {
 223                                 return true;
 224                         }
 225                 }
 226                 return false;
 227         }
 228
 229         /**
 230          * 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
 231          * dependencies have previously been promoted. By default, both the author of the document and the responsible of study has right to
 232          * promote such document. Otherwise, only the user involved in the Promotion step of validation cycle of the selected document has such
 233          * right.
 234          *
 235          * @return true if the user has right to promote the document.
 236          * @see #canDemote()
 237          * @see Publication#promote()
 238          * @see ValidationCycle
 239          */
 240         public boolean canPromote() {
 241                 User manager = _operand.getOwnerStudy().getAuthor();
 242                 User publisher = _cycle.getActor(ValidationStep.PROMOTION); // Null if the default users are involved
 243
 244                 if (_operand.getProgressState() != ProgressState.inWORK) {
 245                         if (_operand.getProgressState() == ProgressState.inDRAFT) {
 246                                 return canReview();
 247                         }
 248                         return false;
 249                 }
 250                 if (publisher == null) {
 251                         if (!_isauthor && !_user.equals(manager)) {
 252                                 return false;
 253                         }
 254                 } else {
 255                         if (!_user.equals(publisher)) {
 256                                 return false;
 257                         }
 258                 }
 259                 List<Relation> use = _operand.value().getRelations(UsesRelation.class);
 260                 for (Iterator<Relation> i = use.iterator(); i.hasNext();) {
 261                         Document depend = (Document) i.next().getTo();
 262                         ProgressState state = depend.getProgressState();
 263                         if (state == ProgressState.EXTERN) {
 264                                 continue; // External documents do not follow this progress state
 265                         }
 266                         if (state == ProgressState.inWORK) {
 267                                 return false;
 268                         }
 269                 }
 270                 return true;
 271         }
 272
 273         /**
 274          * Checks if the user has right to remove the history of the selected document, if exists. Only the responsible of the study have such
 275          * right.
 276          *
 277          * @return true if the user has right to purge the document.
 278          */
 279         public boolean canPurge() {
 280                 User manager = _operand.getOwnerStudy().getAuthor();
 281                 Document doc = _operand.value();
 282
 283                 if (!_user.equals(manager)) {
 284                         return false;
 285                 }
 286                 if (doc.isShared()) {
 287                         return false;
 288                 }
 289                 if (doc.getFirstRelation(VersionsRelation.class) == null) {
 290                         return false;
 291                 }
 292                 return true;
 293         }
 294
 295         /**
 296          * Checks if the user has right to remove the selected document from the study. Both, the author of the document and the responsible of
 297          * the study, have such right, providing that: - the document is neither in review or in approval process - the document is not used by
 298          * any other document
 299          *
 300          * @return true if the user has right to remove the document.
 301          * @see Step#removeDocument(Publication)
 302          */
 303         public boolean canRemove() {
 304                 User manager = _operand.getOwnerStudy().getAuthor();
 305                 ProgressState state = _operand.getProgressState();
 306
 307                 if (!_isauthor && !_user.equals(manager)) {
 308                         return false;
 309                 }
 310                 if (state != ProgressState.inWORK && state != ProgressState.EXTERN) {
 311                         return false;
 312                 }
 313
 314                 List<Publication> using = _operand.getRelations(UsedByRelation.class);
 315                 return using.isEmpty();
 316         }
 317
 318         /**
 319          * Checks if the user has right to rename the selected document. Only the author of the document has such right, providing that the
 320          * document is neither in review nor in approval process.
 321          *
 322          * @return true if the user has right to rename the document.
 323          * @see Publication#rename(String)
 324          */
 325         public boolean canRename() {
 326                 ProgressState state = _operand.getProgressState();
 327
 328                 if (!_isauthor) {
 329                         return false; // In case of external document, the author is the one who has imported the document.
 330                 }
 331                 if (state != ProgressState.inWORK && state != ProgressState.EXTERN) {
 332                         return false;
 333                 }
 334                 return (!_operand.value().isShared());
 335         }
 336
 337         /**
 338          * Checks if the user has right to replace the source file of the selected document. Both, the author of the document and the
 339          * responsible of study has such right, providing that the document is neither in review nor in approval process.
 340          *
 341          * @return true if the user has right to replace the document.
 342          */
 343         public boolean canReplace() {
 344                 User manager = _operand.getOwnerStudy().getAuthor();
 345                 ProgressState state = _operand.getProgressState();
 346
 347                 if (!_isauthor && !_user.equals(manager)) {
 348                         return false; // Supposed to work also in case of external document.
 349                 }
 350                 if (state != ProgressState.inWORK && state != ProgressState.EXTERN) {
 351                         return false;
 352                 }
 353                 return !_operand.value().isShared();
 354         }
 355
 356         /**
 357          * Checks if the user has right to validate the selected document. Only the reviewer of the type of selected document has such right,
 358          * providing that the document is being reviewed and all document dependencies have already been validated.
 359          *
 360          * @return true if the user has right to validate the document
 361          * @see #canUnvalidate()
 362          * @see Publication#review()
 363          * @see ValidationCycle
 364          */
 365         public boolean canReview() {
 366                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 367
 368                 if (!_user.equals(reviewer)) {
 369                         return false;
 370                 }
 371                 if (_operand.getProgressState() != ProgressState.inDRAFT) {
 372                         return false;
 373                 }
 374
 375                 List<Relation> use = _operand.value().getRelations(UsesRelation.class);
 376                 for (Iterator<Relation> i = use.iterator(); i.hasNext();) {
 377                         Document depend = (Document) i.next().getTo();
 378                         ProgressState state = depend.getProgressState();
 379                         if (state == ProgressState.EXTERN) {
 380                                 continue; // External documents do not follow this progress state
 381                         }
 382                         if (state == ProgressState.inWORK || state == ProgressState.inDRAFT) {
 383                                 return false;
 384                         }
 385                 }
 386                 return true;
 387         }
 388
 389         /**
 390          * Checks if the user has right to undo the validation operation of the selected document. Both, the author and the reviewer of a
 391          * validated document, have such right.
 392          *
 393          * @return true if the user has right to undo the validation operation
 394          * @see #canDemote()
 395          * @see #canReview()
 396          * @see Publication#invalidate()
 397          * @see ValidationCycle
 398          */
 399         public boolean canInvalidate() {
 400                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 401                 ProgressState mystate = _operand.value().getProgressState();
 402
 403                 if (mystate != ProgressState.inCHECK) {
 404                         return false;
 405                 }
 406                 if (!_isauthor && !_user.equals(reviewer)) {
 407                         return false;
 408                 }
 409
 410                 List<Relation> use = _operand.value()
 411                                 .getRelations(UsedByRelation.class);
 412                 for (Iterator<Relation> i = use.iterator(); i.hasNext();) {
 413                         Document depend = (Document) i.next().getTo();
 414                         ProgressState state = depend.getProgressState();
 415                         if (mystate == ProgressState.inDRAFT
 416                                         && state != ProgressState.inWORK) {
 417                                 return false;
 418                         }
 419                         if (mystate == ProgressState.inCHECK
 420                                         && (state != ProgressState.inDRAFT && state != ProgressState.inWORK)) {
 421                                 return false;
 422                         }
 423                 }
 424                 return true;
 425         }
 426
 427         /**
 428          * Checks if the user has right to version the selected document. In-Work documents can be versioned by both, the author of the document
 429          * and the responsible of study, while documents In-Draft can be versioned by the reviewer only. Additionally, Approved documents can
 430          * also be versioned by their author in order to enter in a new modification validation cycle.
 431          *
 432          * @return true if the user has right to version the document.
 433          * @see Step#versionDocument(Publication)
 434          * @see Step#versionDocument(Publication, Document.Properties)
 435          * @see Step#versionDocument(Publication, String)
 436          */
 437         public boolean canVersion() {
 438                 User manager = _operand.getOwnerStudy().getAuthor();
 439                 User reviewer = _cycle.getActor(ValidationStep.REVIEW); // May be null if not reviewable
 440                 ProgressState state = _operand.value().getProgressState();
 441
 442                 if (state == ProgressState.inWORK) {
 443                         if (_isauthor || _user.equals(manager)) {
 444                                 return true;
 445                         }
 446                 } else if (state == ProgressState.inDRAFT) {
 447                         if (_user.equals(reviewer)) {
 448                                 return true;
 449                         }
 450                 } else if (state == ProgressState.APPROVED) {
 451                         if (_isauthor) {
 452                                 return true;
 453                         }
 454
 455                 } else if (state == ProgressState.EXTERN) {
 456                         if (_isauthor || _user.equals(manager)) {
 457                                 return true;
 458                         }
 459                 }
 460
 461                 return false;
 462         }
 463
 464         // ==============================================================================================================================
 465         // Getter
 466         // ==============================================================================================================================
 467
 468         /**
 469          * Returns the document subject of checks according to this user rights.
 470          *
 471          * @return the document subject of checks.
 472          */
 473         public Document getOperand() {
 474                 return _operand.value();
 475         }
 476
 477         /**
 478          * Get the study service.
 479          *
 480          * @return the study service
 481          */
 482         private StudyService getStudyService() {
 483                 return ServiceLocatorImpl.getInstance().getStudyService();
 484         }
 485 }