def _checkProtection(self):
     if self._session.isClosed():
         raise ServiceAccessError(
             _(""""The modification of the session "%s" is not allowed because it is closed""")
             % self._session.getTitle()
         )
     ProtectedModificationService._checkProtection(self)

 def _checkParams(self):
     ContributionModifBase._checkParams(self)
     
     subcId = self._params.get('subContribution',None)
     
     self._subCont = self._target.getSubContributionById(subcId) 
         
     ProtectedModificationService._checkProtection(self)

    def _checkProtection(self):
        hasRights = False;
        if RCPaperReviewManager.hasRights(self):
            hasRights = True
        elif RCReferee.hasRights(self):
            isRefereeOfAllContributions = True
            for contribution in self._contributions:
                if not contribution.getReviewManager().isReferee(self.getAW().getUser()):
                    isRefereeOfAllContributions = False
                    break
            hasRights = isRefereeOfAllContributions

        if not hasRights:
            ProtectedModificationService._checkProtection(self)

    def _checkProtection(self):
        owner = self._material.getOwner()

        # Conference submitters have access
        if isinstance(owner, conference.Conference) and owner.getAccessController().canUserSubmit(self._aw.getUser()):
            return

        # There are two exceptions to the normal permission scheme:
        # (sub-)contribution submitters and session coordinators

        # in case the owner is a (sub-)contribution, we should
        # allow submitters
        if isinstance(owner, conference.Contribution) or isinstance(owner, conference.SubContribution):

            reviewingState = self._material.getReviewingState()

            if (
                reviewingState < 3
                and owner.canUserSubmit(  # it means the papers has not been submitted yet (or not reviewing material)
                    self._aw.getUser()
                )
            ):
                # Submitters have access
                return
            # status = 3 means the paper is under review (submitted but not reviewed)
            # status = 2 means that the author has not yet submitted the material
            elif (
                isinstance(owner, conference.Contribution)
                and RCContributionPaperReviewingStaff.hasRights(
                    self, contribution=owner, includingContentReviewer=False
                )
                and reviewingState in [2, 3]
            ):
                return
            elif owner.getSession() and owner.getSession().canCoordinate(self._aw, "modifContribs"):
                # Coordinators of the parent session have access
                return

        # if it's associated with a session, coordinators
        # should be allowed
        elif self._material.getSession() != None and self._material.getSession().canCoordinate(self._aw):
            # Session coordinators have access
            return

        try:
            ProtectedModificationService._checkProtection(self)
        except ModificationError:
            raise ServiceAccessError(_("you are not authorised to manage material " "for this contribution"))

    def _checkParams(self):
        ProtectedModificationService._checkParams(self)

        pm = ParameterManager(self._params)

        l = locators.WebLocator()

        # TODO: This chain could (should) be repalced by a more generic
        # locator, something like:
        # l.setParams(self._params)
        # l.getObject() # retrieves whatever object has been extracted

        # will check cotnribution and session as well, as fallback cases
        l.setSubContribution(self._params, 0)
        # will check if it is compiling minutes
        self._compile = self._params.get("compile", False)

        self._target = l.getObject()

        # TODO: change str to some kind of html sanitization
        self._text = pm.extract("value", pType=str, allowEmpty=True)

    def _checkProtection(self):

        if self._material: #target is a material
            if isinstance(self._material.getOwner(), conference.Contribution) and \
                self._material.getOwner().canUserSubmit(self._aw.getUser()) and \
                self._material.getReviewingState() < 3:
                return
            elif self._material.getSession() != None and \
                   self._material.getSession().canCoordinate(self._aw, "modifContribs"):
                # Session coordiantors have access
                return
        elif isinstance(self._target, conference.Contribution): #target is a contribution
            if self._target.canUserSubmit(self._aw.getUser()):
                return

        try:
            ProtectedModificationService._checkProtection(self)
        except ModificationError:
            raise ServiceError("ERR-M2", _("you are not authorised to manage material for this contribution"))
        except Exception, e:
            raise e

 def _checkParams(self):
     CategoryBase._checkParams(self)
     ProtectedModificationService._checkParams(self)

 def _checkProtection(self):
     if self._target.getSession() != None:
         if self._target.getSession().canCoordinate(self.getAW(), "modifContribs"):
             return
     ProtectedModificationService._checkProtection(self)

 def _checkParams(self):
     ContributionBase._checkParams(self)
     ProtectedModificationService._checkParams(self)

 def _checkParams(self):
     ConferenceBase._checkParams(self)
     ProtectedModificationService._checkParams(self)

 def _checkProtection(self):
     ProtectedModificationService._checkProtection(self)

 def __init__(self, params):
     ProtectedModificationService.__init__(self, params)

 def __init__(self, params, session, req):
     ProtectedModificationService.__init__(self, params, session, req)

 def _checkProtection(self):
     if (type(self._target) == conference.Session and not self._target.canCoordinate(self.getAW())) or (
         type(self._target) == conference.Contribution and not self._target.canUserSubmit(self._getUser())
     ):
         ProtectedModificationService._checkProtection(self)