source: indico/indico/MaKaC/webinterface/rh/contribMod.py @ 14d8ef

burotelhello-world-walkthroughipv6v0.98-seriesv0.98.2v0.98.3v0.98b1v0.98b2v0.99v1.0v1.1
Last change on this file since 14d8ef was 14d8ef, checked in by Jose Benito <jose.benito.gonzalez@…>, 3 years ago

[FIX] Exception in protection and tool tabs

  • Fix: exception when tried to open these tabs with paper reviewing staff users.
  • Property mode set to 100644
File size: 77.0 KB
Line 
1# -*- coding: utf-8 -*-
2##
3##
4## This file is part of CDS Indico.
5## Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 CERN.
6##
7## CDS Indico is free software; you can redistribute it and/or
8## modify it under the terms of the GNU General Public License as
9## published by the Free Software Foundation; either version 2 of the
10## License, or (at your option) any later version.
11##
12## CDS Indico is distributed in the hope that it will be useful, but
13## WITHOUT ANY WARRANTY; without even the implied warranty of
14## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15## General Public License for more details.
16##
17## You should have received a copy of the GNU General Public License
18## along with CDS Indico; if not, write to the Free Software Foundation, Inc.,
19## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
20
21import MaKaC.webinterface.locators as locators
22import MaKaC.webinterface.urlHandlers as urlHandlers
23import MaKaC.webinterface.materialFactories as materialFactories
24import MaKaC.webinterface.pages.contributions as contributions
25import MaKaC.conference as conference
26import MaKaC.user as user
27import MaKaC.domain as domain
28import MaKaC.webinterface.webFactoryRegistry as webFactoryRegistry
29from MaKaC.webinterface.rh.base import RHModificationBaseProtected
30from MaKaC.common.xmlGen import XMLGen
31from MaKaC.common.utils import parseDateTime
32from MaKaC.common import Config
33from MaKaC.webinterface.rh.conferenceBase import RHSubmitMaterialBase
34from MaKaC.webinterface.rh.base import RoomBookingDBMixin
35from MaKaC.PDFinterface.conference import ConfManagerContribToPDF
36from MaKaC.errors import FormValuesError
37from MaKaC.conference import SubContribParticipation
38from MaKaC.errors import MaKaCError
39from MaKaC.i18n import _
40from MaKaC.webinterface.pages.conferences import WPConferenceModificationClosed
41
42class RHContribModifBase(RHModificationBaseProtected):
43    """ Base RH for contribution modification.
44        Sets the _target (the contribution) and the _conf (the conference)
45    """
46
47    def _checkParams(self, params):
48        l = locators.WebLocator()
49        l.setContribution(params)
50        self._target = l.getObject()
51        self._conf = self._target.getConference()
52
53    def getWebFactory(self):
54        wr = webFactoryRegistry.WebFactoryRegistry()
55        self._wf = wr.getFactory(self._target.getConference())
56        return self._wf
57
58class RCSessionCoordinator(object):
59    @staticmethod
60    def hasRights(request):
61        """ Returns true if the user is a Session Coordinator
62        """
63        if request._target.getSession() != None:
64            return request._target.getSession().canCoordinate(request.getAW(), "modifContribs")
65        else:
66            return False
67
68class RCContributionPaperReviewingStaff(object):
69
70    @staticmethod
71    def hasRights(request):
72        """ Returns true if the user is a PRM, or a Referee / Editor / Reviewer of the target contribution
73        """
74        user = request.getAW().getUser()
75        confReview = request._target.getConference().getConfReview()
76        confReviewChoice = confReview.getChoice()
77        reviewManager = request._target.getReviewManager()
78        return (confReview.isPaperReviewManager(user) or \
79               (reviewManager.hasReferee() and reviewManager.isReferee(user)) or \
80               ((confReviewChoice == 3 or confReviewChoice == 4) and reviewManager.hasEditor() and reviewManager.isEditor(user)) or \
81               ((confReviewChoice == 2 or confReviewChoice == 4) and request._target.getReviewManager().isReviewer(user)))
82
83class RCContributionReferee(object):
84    @staticmethod
85    def hasRights(request):
86        """ Returns true if the user is a referee of the target contribution
87        """
88        user = request.getAW().getUser()
89        reviewManager = request._target.getReviewManager()
90        return reviewManager.hasReferee() and reviewManager.isReferee(user)
91
92class RCContributionEditor(object):
93    @staticmethod
94    def hasRights(request):
95        """ Returns true if the user is an editor of the target contribution
96        """
97
98        user = request.getAW().getUser()
99        reviewManager = request._target.getReviewManager()
100        return reviewManager.hasEditor() and reviewManager.isEditor(user)
101
102class RCContributionReviewer(object):
103    @staticmethod
104    def hasRights(request):
105        """ Returns true if the user is a reviewer of the target contribution
106        """
107        user = request.getAW().getUser()
108        reviewManager = request._target.getReviewManager()
109        return reviewManager.isReviewer(user)
110
111class RHContribModifBaseSpecialSesCoordRights(RHContribModifBase):
112    """ Base class for any RH where a Session Coordinator has the rights to perform the request
113    """
114
115    def _checkProtection(self):
116        if not RCSessionCoordinator.hasRights(self):
117            RHContribModifBase._checkProtection(self)
118
119class RHContribModifBaseReviewingStaffRights(RHContribModifBase):
120    """ Base class for any RH where a member of the Paper Reviewing staff
121        (a PRM, or a Referee / Editor / Reviewer of the target contribution)
122        has the rights to perform the request
123    """
124
125    def _checkProtection(self):
126        if not RCContributionPaperReviewingStaff.hasRights(self):
127            RHContribModifBase._checkProtection(self);
128
129class RHContribModifBaseSpecialSesCoordAndReviewingStaffRights(RHContribModifBase):
130    """ Base class for any RH where a member of the Paper Reviewing staff
131        (a PRM, or a Referee / Editor / Reviewer of the target contribution),
132        OR  a Session Coordinator has the rights to perform the request
133    """
134
135    def _checkProtection(self):
136        if not (RCSessionCoordinator.hasRights(self) or RCContributionPaperReviewingStaff.hasRights(self)):
137            RHContribModifBase._checkProtection(self);
138
139class RHContributionModification(RHContribModifBaseSpecialSesCoordAndReviewingStaffRights):
140    _uh = urlHandlers.UHContributionModification
141
142    def _checkParams(self, params):
143        RHContribModifBase._checkParams(self, params)
144        params["days"] = params.get("day", "all")
145        if params.get("day", None) is not None :
146            del params["day"]
147
148    def _process(self):
149        params = self._getRequestParams()
150        if self._target.getOwner().isClosed():
151            p = contributions.WPContributionModificationClosed(self, self._target)
152        else:
153            wf = self.getWebFactory()
154            if wf != None:
155                p = wf.getContributionModification(self, self._target)
156            else:
157                p = contributions.WPContributionModification(self, self._target)
158        return p.display(**params)
159
160class RHWithdraw(RHContribModifBaseSpecialSesCoordRights):
161    _uh=urlHandlers.UHContribModWithdraw
162
163    def _checkParams(self, params):
164        RHContribModifBase._checkParams(self, params)
165        self._action=""
166        self._comment=""
167        if params.has_key("REACTIVATE"):
168            self._action="REACTIVATE"
169        elif params.has_key("OK"):
170            self._action="WITHDRAW"
171            self._comment=params.get("comment", "")
172        elif params.has_key("CANCEL"):
173            self._action="CANCEL"
174
175    def _process(self):
176        url=urlHandlers.UHContributionModification.getURL(self._target)
177        if self._action=="REACTIVATE":
178            self._target.withdraw(self._getUser(), self._comment)
179            self._redirect(url)
180            return
181        elif self._action=="WITHDRAW":
182            self._target.withdraw(self._getUser(), self._comment)
183            self._redirect(url)
184            return
185        elif self._action=="CANCEL":
186            self._redirect(url)
187            return
188        p=contributions.WPModWithdraw(self, self._target)
189        return p.display()
190
191
192class RHContributionAC(RHContribModifBaseSpecialSesCoordRights):
193    _uh = urlHandlers.UHContribModifAC
194
195    def _checkParams(self, params):
196        RHContribModifBase._checkParams(self, params)
197        params["days"] = params.get("day", "all")
198        if params.get("day", None) is not None :
199            del params["day"]
200
201    def _process(self):
202        params = self._getRequestParams()
203        if self._target.getOwner().isClosed():
204            p = contributions.WPContributionModificationClosed(self, self._target)
205        else:
206            p = contributions.WPContribModifAC(self, self._target)
207            wf = self.getWebFactory()
208            if wf != None:
209                p = wf.getContribModifAC(self, self._target)
210        return p.display(**params)
211
212
213class RHContributionSC(RHContribModifBaseSpecialSesCoordAndReviewingStaffRights):
214    _uh = urlHandlers.UHContribModifSubCont
215
216    def _checkParams(self, params):
217        RHContribModifBase._checkParams(self, params)
218        params["days"] = params.get("day", "all")
219        if params.get("day", None) is not None :
220            del params["day"]
221
222    def _process(self):
223        params = self._getRequestParams()
224        p = contributions.WPContribModifSC(self, self._target)
225        wf = self.getWebFactory()
226        if wf != None:
227            p = wf.getContribModifSC(self, self._target)
228        return p.display(**params)
229
230class RHSubContribActions(RHContribModifBaseSpecialSesCoordRights):
231    _uh = urlHandlers.UHSubContribActions
232
233    def _checkParams(self, params):
234        RHContribModifBase._checkParams(self, params)
235        self._confirm = params.has_key("confirm")
236        self._scIds = self._normaliseListParam(params.get("selSubContribs", []))
237        self._action=None
238        if "cancel" in params:
239            return
240        self._action=[]
241        for id in self._scIds:
242            sc = self._target.getSubContributionById(id)
243            self._action.append(_ActionSubContribDelete(self, self._target, sc))
244        if params.has_key("oldpos") and params["oldpos"]!='':
245            self._action = _ActionSubContribMove(self, params['newpos'+params['oldpos']], params['oldpos'])
246
247    def _process(self):
248        if self._action is not None:
249            if isinstance(self._action, list):
250                for act in self._action:
251                    act.perform()
252            else:
253                self._action.perform()
254        self._redirect(urlHandlers.UHContribModifSubCont.getURL(self._target))
255
256class _ActionSubContribDelete:
257
258    def __init__(self, rh, target, sc):
259        self._rh = rh
260        self._target = target
261        self._sc = sc
262
263    def perform(self):
264        self._target.removeSubContribution(self._sc)
265
266class _ActionSubContribMove:
267
268    def __init__(self, rh, newpos, oldpos):
269        self._rh = rh
270        self._newpos = int(newpos)
271        self._oldpos = int(oldpos)
272
273    def perform(self):
274        scList = self._rh._target.getSubContributionList()
275        order = 0
276        movedsubcontrib = scList[self._oldpos]
277        del scList[self._oldpos]
278        scList.insert(self._newpos, movedsubcontrib)
279        self._rh._target.notifyModification()
280
281        #for sc in scList:
282        #    sc.setOrder(scList.index(sc))
283
284#-------------------------------------------------------------------------------------
285
286class RHContributionAddSC(RHContribModifBaseSpecialSesCoordRights):
287    _uh = urlHandlers.UHContribAddSubCont
288
289    def _process(self):
290        p = contributions.WPContribAddSC(self, self._target)
291        params = self._getRequestParams()
292        if params.get("recalled", None) is None :
293            self._removePreservedParams()
294            self._removeDefinedList("presenter")
295        params.update(self._getPreservedParams())
296        wf = self.getWebFactory()
297        if wf != None:
298            p = wf.getContribAddSC(self, self._target)
299
300        params["presenterDefined"] = self._getDefinedDisplayList("presenter")
301        params["presenterOptions"] = self._getPersonOptions("presenter")
302
303        params["days"] = params.get("day", "all")
304        if params.get("day", None) is not None :
305            del params["day"]
306
307        return p.display(**params)
308
309    def _getDefinedDisplayList(self, typeName):
310        return self._websession.getVar("%sList"%typeName)
311
312    def _getPreservedParams(self):
313        params = self._websession.getVar("preservedParams")
314        if params is None :
315            return {}
316        return params
317
318    def _removePreservedParams(self):
319        self._websession.setVar("preservedParams", None)
320
321    def _removeDefinedList(self, typeName):
322        self._websession.setVar("%sList"%typeName, None)
323
324    def _personInDefinedList(self, typeName, person):
325        list = self._websession.getVar("%sList"%typeName)
326        if list is None :
327            return False
328        for p in list :
329            if person.getFullName()+" "+person.getEmail() == p[0].getFullName()+" "+p[0].getEmail() :
330                return True
331        return False
332
333    def _getPersonOptions(self, typeName):
334        html = []
335        names = []
336        text = {}
337        html.append("""<option value=""> </option>""")
338        for contribution in self._target.getConference().getContributionList() :
339            for speaker in contribution.getSpeakerList() :
340                name = speaker.getFullNameNoTitle()
341                if not name in names and not self._personInDefinedList(typeName, speaker):
342                    text[name] = """<option value="s%s-%s">%s</option>"""%(contribution.getId(),speaker.getId(),name)
343                    names.append(name)
344            for author in contribution.getAuthorList() :
345                name = author.getFullNameNoTitle()
346                if not name in names and not self._personInDefinedList(typeName, author):
347                    text[name] = """<option value="a%s-%s">%s</option>"""%(contribution.getId(),author.getId(),name)
348                    names.append(name)
349            for coauthor in contribution.getCoAuthorList() :
350                name = coauthor.getFullNameNoTitle()
351                if not name in names and not self._personInDefinedList(typeName, coauthor):
352                    text[name] = """<option value="c%s-%s">%s</option>"""%(contribution.getId(),coauthor.getId(),name)
353                    names.append(name)
354        names.sort()
355        for name in names:
356            html.append(text[name])
357        return "".join(html)
358
359
360#-------------------------------------------------------------------------------------
361
362class RHContributionCreateSC(RHContribModifBaseSpecialSesCoordRights):
363    _uh = urlHandlers.UHContribCreateSubCont
364
365    def _process(self):
366
367        params = self._getRequestParams()
368        #params.update(self._getPreservedParams())
369        sc = self._target
370        """self._target - contribution owning new subcontribution"""
371
372        if ("ok" in params):
373            sc = self._target.newSubContribution()
374            sc.setTitle( params.get("title", "") )
375            sc.setDescription( params.get("description", "") )
376            sc.setKeywords( params.get("keywords", "") )
377            sc.setDuration( params.get("durationHours", ""), \
378                             params.get("durationMinutes", "") )
379            sc.setSpeakerText( params.get("speakers", "") )
380            sc.setParent(self._target)
381            for presenter in self._getDefinedList("presenter") :
382                sc.newSpeaker(presenter[0])
383
384            logInfo = sc.getLogInfo()
385            logInfo["subject"] = "Create new subcontribution: %s"%sc.getTitle()
386            self._target.getConference().getLogHandler().logAction(logInfo, "Timetable/SubContribution", self._getUser())
387
388            self._removePreservedParams()
389            self._removeDefinedList("presenter")
390            self._redirect(urlHandlers.UHContribModifSubCont.getURL(sc))
391        elif params.get("performedAction", "") == "New presenter" :
392            self._preserveParams(params)
393            self._redirect(urlHandlers.UHContribCreateSubContPresenterNew.getURL(self._target))
394        elif params.get("performedAction","") == "Search presenter" :
395            self._preserveParams(params)
396            self._redirect(urlHandlers.UHContribCreateSubContPresenterSearch.getURL(self._target))
397        elif params.get("performedAction", "") == "Add as presenter" :
398            self._preserveParams(params)
399            url = urlHandlers.UHContribCreateSubContPersonAdd.getURL(self._target)
400            url.addParam("typeName", "presenter")
401            url.addParam("orgin", "added")
402            self._redirect(url)
403        elif params.get("performedAction", "") == "Remove presenters" :
404            self._preserveParams(params)
405            self._removePersons(params, "presenter")
406            url = urlHandlers.UHContribAddSubCont.getURL(self._target)
407            url.addParam("recalled", "true")
408            self._redirect(url)
409        else:
410            self._removePreservedParams()
411            self._removeDefinedList("presenter")
412            self._redirect(urlHandlers.UHContribModifSubCont.getURL(sc))
413
414    def _getPreservedParams(self):
415        params = self._websession.getVar("preservedParams")
416        if params is None :
417            return {}
418        return params
419
420    def _preserveParams(self, params):
421        self._websession.setVar("preservedParams", params)
422
423    def _removePreservedParams(self):
424        self._websession.setVar("preservedParams", None)
425
426    def _getDefinedList(self, typeName):
427        definedList = self._websession.getVar("%sList"%typeName)
428        if definedList is None :
429            return []
430        return definedList
431
432    def _setDefinedList(self, definedList, typeName):
433        self._websession.setVar("%sList"%typeName, definedList)
434
435    def _removeDefinedList(self, typeName):
436        self._websession.setVar("%sList"%typeName, None)
437
438    def _removePersons(self, params, typeName):
439        persons = self._normaliseListParam(params.get("%ss"%typeName, []))
440        definedList = self._getDefinedList(typeName)
441        personsToRemove = []
442        for p in persons :
443            if int(p) < len(definedList) or int(p) >= 0 :
444                personsToRemove.append(definedList[int(p)])
445        for person in personsToRemove :
446            definedList.remove(person)
447        self._setDefinedList(definedList, typeName)
448
449#-------------------------------------------------------------------------------------
450
451class RHNewSubcontributionPresenterSearch(RHContribModifBaseSpecialSesCoordRights):
452    _uh = urlHandlers.UHContribCreateSubContPresenterSearch
453
454    def _checkParams(self, params):
455        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
456
457    def _process(self):
458        params = self._getRequestParams()
459
460        params["newButtonAction"] = str(urlHandlers.UHContribCreateSubContPresenterNew.getURL())
461        addURL = urlHandlers.UHContribCreateSubContPersonAdd.getURL()
462        addURL.addParam("orgin", "selected")
463        addURL.addParam("typeName", "presenter")
464        params["addURL"] = addURL
465        p = contributions.WSubContributionCreationPresenterSelect(self, self._target)
466        return p.display(**params)
467
468#-------------------------------------------------------------------------------------
469
470class RHNewSubcontributionPresenterNew(RHContribModifBaseSpecialSesCoordRights):
471    _uh = urlHandlers.UHContribCreateSubContPresenterNew
472
473    def _checkParams(self, params):
474        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
475
476    def _process(self):
477        p = contributions.WSubContributionCreationPresenterNew(self, self._target)
478        return p.display()
479
480#-------------------------------------------------------------------------------------
481
482class RHNewSubcontributionPersonAdd(RHContribModifBaseSpecialSesCoordRights):
483    _uh = urlHandlers.UHContribCreateSubContPersonAdd
484
485    def _checkParams(self, params):
486        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
487        self._typeName = params.get("typeName", None)
488        if self._typeName  is None :
489            raise MaKaCError( _("Type name of the person to add is not set."))
490
491    def _process(self):
492        params = self._getRequestParams()
493        self._errorList = []
494
495        definedList = self._getDefinedList(self._typeName)
496        if definedList is None :
497            definedList = []
498
499        if params.get("orgin", "") == "new" :
500            if params.get("ok", None) is None :
501                url = urlHandlers.UHContribAddSubCont.getURL(self._target)
502                url.addParam("recalled", "true")
503                self._redirect(url)
504                return
505            else :
506                person = SubContribParticipation()
507                person.setFirstName(params["name"])
508                person.setFamilyName(params["surName"])
509                person.setEmail(params["email"])
510                person.setAffiliation(params["affiliation"])
511                person.setAddress(params["address"])
512                person.setPhone(params["phone"])
513                person.setTitle(params["title"])
514                person.setFax(params["fax"])
515                if not self._alreadyDefined(person, definedList) :
516                    definedList.append([person, params.has_key("submissionControl")])
517                else :
518                    self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
519
520        elif params.get("orgin", "") == "selected":
521            selectedList = self._normaliseListParam(self._getRequestParams().get("selectedPrincipals", []))
522
523            for s in selectedList :
524                if s[0:8] == "*author*" :
525                    auths = self._target.getConference().getAuthorIndex()
526                    selected = auths.getById(s[9:])[0]
527                else :
528                    ph = user.PrincipalHolder()
529                    selected = ph.getById(s)
530                if isinstance(selected, user.Avatar) :
531                    person = SubContribParticipation()
532                    person.setDataFromAvatar(selected)
533                    if not self._alreadyDefined(person, definedList) :
534                        definedList.append([person, params.has_key("submissionControl")])
535                    else :
536                        self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
537
538                elif isinstance(selected, user.Group) :
539                    for member in selected.getMemberList() :
540                        person = SubContribParticipation()
541                        person.setDataFromAvatar(member)
542                        if not self._alreadyDefined(person, definedList) :
543                            definedList.append([person, params.has_key("submissionControl")])
544                        else :
545                            self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
546                else :
547                    person = SubContribParticipation()
548                    person.setTitle(selected.getTitle())
549                    person.setFirstName(selected.getFirstName())
550                    person.setFamilyName(selected.getFamilyName())
551                    person.setEmail(selected.getEmail())
552                    person.setAddress(selected.getAddress())
553                    person.setAffiliation(selected.getAffiliation())
554                    person.setPhone(selected.getPhone())
555                    person.setFax(selected.getFax())
556                    if not self._alreadyDefined(person, definedList) :
557                        definedList.append([person, params.has_key("submissionControl")])
558                    else :
559                        self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
560
561        elif params.get("orgin", "") == "added" :
562            preservedParams = self._getPreservedParams()
563            chosen = preservedParams.get("%sChosen"%self._typeName, None)
564            if chosen is None or chosen == "" :
565                url = urlHandlers.UHContribAddSubCont.getURL(self._target)
566                url.addParam("recalled", "true")
567                self._redirect(url)
568                return
569            index = chosen.find("-")
570            objectId = chosen[1:index]
571            chosenId = chosen[index+1:len(chosen)]
572            if chosen[0:1] == "d" :
573                object = self._target.getConference().getSessionById(objectId)
574            else :
575                object = self._target.getConference().getContributionById(objectId)
576            chosenPerson = None
577            if chosen[0:1] == "s" :
578                chosenPerson = object.getSpeakerById(chosenId)
579            elif chosen[0:1] == "a" :
580                chosenPerson = object.getAuthorById(chosenId)
581            elif chosen[0:1] == "c" :
582                chosenPerson = object.getCoAuthorById(chosenId)
583            elif chosen[0:1] == "d" :
584                chosenPerson = object.getConvenerById(chosenId)
585            elif index ==  -1 : #person data doesn't contain proper id
586                if self._getUser() and chosenId in self._getUser().getPersonalInfo().getBasket().getUsers() :   #checking if such person is listed on favourites
587                    chosenPerson = self._getUser().getPersonalInfo().getBasket().getUsers()[chosenId]
588            if chosenPerson is None :
589                self._redirect(urlHandlers.UHConfModScheduleNewContrib.getURL(self._target))
590                return
591            person = SubContribParticipation()
592            person.setTitle(chosenPerson.getTitle())
593            person.setFirstName(chosenPerson.getFirstName())
594            person.setFamilyName(chosenPerson.getFamilyName())
595            person.setEmail(chosenPerson.getEmail())
596            person.setAddress(chosenPerson.getAddress())
597            person.setAffiliation(chosenPerson.getAffiliation())
598            person.setPhone(chosenPerson.getPhone())
599            person.setFax(chosenPerson.getFax())
600            if not self._alreadyDefined(person, definedList) :
601                definedList.append([person, params.has_key("submissionControl")])
602            else :
603                self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
604        else :
605            self._redirect(urlHandlers.UHConfModifSchedule.getURL(self._target))
606            return
607        preservedParams = self._getPreservedParams()
608        preservedParams["errorMsg"] = self._errorList
609        self._preserveParams(preservedParams)
610        self._websession.setVar("%sList"%self._typeName, definedList)
611
612        url = urlHandlers.UHContribAddSubCont.getURL(self._target)
613        url.addParam("recalled", "true")
614        self._redirect(url)
615
616
617    def _getDefinedList(self, typeName):
618        definedList = self._websession.getVar("%sList"%typeName)
619        if definedList is None :
620            return []
621        return definedList
622
623    def _alreadyDefined(self, person, definedList):
624        if person is None :
625            return True
626        if definedList is None :
627            return False
628        fullName = person.getFullName()
629        for p in definedList :
630            if p[0].getFullName() == fullName :
631                return True
632        return False
633
634    def _getPreservedParams(self):
635        params = self._websession.getVar("preservedParams")
636        if params is None :
637            return {}
638        return params
639
640    def _preserveParams(self, params):
641        self._websession.setVar("preservedParams", params)
642
643    def _removePreservedParams(self):
644        self._websession.setVar("preservedParams", None)
645
646#-------------------------------------------------------------------------------------
647
648
649#class RHContributionDeleteSC( RHContribModifBase ):
650#    _uh = urlHandlers.UHContriDeleteSubCont
651#
652#    def _checkParams( self, params ):
653#        RHContribModifBase._checkParams( self, params )
654#        self._confirm = params.has_key( "confirm" )
655#        self._cancel = params.has_key( "cancel" )
656#        self._scIds = self._normaliseListParam( params.get("selSubContribs", []) )
657
658#    def _process( self ):
659#        for id in self._scIds:
660#            sc = self._target.getSubContributionById( id )
661#            self._target.removeSubContribution( sc )
662#        self._redirect( urlHandlers.UHContribModifSubCont.getURL( self._target ) )
663
664
665class RHContributionUpSC(RHContribModifBaseSpecialSesCoordRights):
666    _uh = urlHandlers.UHContribUpSubCont
667
668    def _checkParams(self, params):
669        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
670        self._scId = params.get("subContId", "")
671
672    def _process(self):
673        sc = self._target.getSubContributionById(self._scId)
674        self._target.upSubContribution(sc)
675        self._redirect(urlHandlers.UHContribModifSubCont.getURL(self._target))
676
677
678class RHContributionDownSC(RHContribModifBaseSpecialSesCoordRights):
679    _uh = urlHandlers.UHContribDownSubCont
680
681    def _checkParams(self, params):
682        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
683        self._scId = params.get("subContId", "")
684
685    def _process(self):
686        sc = self._target.getSubContributionById(self._scId)
687        self._target.downSubContribution(sc)
688        self._redirect(urlHandlers.UHContribModifSubCont.getURL(self._target))
689
690
691class RHContributionTools(RHContribModifBaseSpecialSesCoordRights):
692    _uh = urlHandlers.UHContribModifTools
693
694    def _process(self):
695        if self._target.getOwner().isClosed():
696            p = contributions.WPContributionModificationClosed(self, self._target)
697        else:
698            p = contributions.WPContributionModifTools(self, self._target)
699            wf = self.getWebFactory()
700            if wf != None:
701                p = wf.getContributionModifTools(self, self._target)
702        return p.display()
703
704
705class RHContributionData( RoomBookingDBMixin, RHContribModifBaseSpecialSesCoordRights ):
706    _uh = urlHandlers.UHContributionDataModif
707
708    def _checkParams( self, params ):
709        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
710
711        self._evt = self._target
712
713    def _process(self):
714        if self._target.getOwner().isClosed():
715            p = contributions.WPContributionModificationClosed(self, self._target)
716        else:
717            p = contributions.WPEditData(self, self._target)
718            wf = self.getWebFactory()
719            if wf != None:
720                p = wf.getContributionEditData(self, self._target)
721        return p.display(**self._getRequestParams())
722
723
724class RHContributionModifData(RHContribModifBaseSpecialSesCoordRights):
725    _uh = urlHandlers.UHContributionDataModification
726
727    def _checkParams(self, params):
728        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
729        self._type=None
730        self._check = int(params.get("check", 1))
731        if params.has_key("type") and params["type"].strip()!="":
732            self._type=self._target.getConference().getContribTypeById(params["type"])
733        self._cancel = params.has_key("cancel")
734
735    def _process(self):
736        if not self._cancel:
737            params = self._getRequestParams()
738
739            if params.has_key("dateTime"):
740                dateTime = parseDateTime(params["dateTime"])
741                params["sYear"] = dateTime.year
742                params["sMonth"] = dateTime.month
743                params["sDay"] = dateTime.day
744                params["sHour"] = dateTime.hour
745                params["sMinute"] = dateTime.minute
746            else:
747                params["sYear"] = ""
748                params["sMonth"] = ""
749                params["sDay"] = ""
750                params["sHour"] = ""
751                params["sMinute"] = ""
752
753            if params.has_key("duration"):
754                params["durMins"] = params["duration"];
755            else:
756                params["durMins"] = ""
757            self._target.setValues(params)
758            self._target.setType(self._type)
759        self._redirect(urlHandlers.UHContributionModification.getURL(self._target))
760
761
762class RHSearchPrimaryAuthor (RHContribModifBaseSpecialSesCoordRights):
763    def _process(self):
764        p=contributions.WPModSearchPrimAuthor(self, self._target)
765        return p.display(**self._getRequestParams())
766
767class RHSearchAddPrimaryAuthor (RHContribModifBaseSpecialSesCoordRights):
768
769    def _newPrimAuthor(self, a):
770        auth = conference.ContributionParticipation()
771        p = self._getRequestParams()
772        auth.setTitle(a.getTitle())
773        auth.setFirstName(a.getName())
774        auth.setFamilyName(a.getSurName())
775        auth.setAffiliation(a.getOrganisation())
776        auth.setEmail(a.getEmail())
777        auth.setAddress(a.getAddress())
778        auth.setPhone(a.getTelephone())
779        auth.setFax(a.getFax())
780        self._target.addPrimaryAuthor(auth)
781        return auth
782
783    def _newPrimAuthorFromAuthor(self, a):
784        auth = conference.ContributionParticipation()
785        p = self._getRequestParams()
786        auth.setTitle(a.getTitle())
787        auth.setFirstName(a.getName())
788        auth.setFamilyName(a.getSurName())
789        auth.setAffiliation(a.getAffiliation())
790        auth.setEmail(a.getEmail())
791        auth.setAddress(a.getAddress())
792        auth.setPhone(a.getPhone())
793        auth.setFax(a.getFax())
794        self._target.addPrimaryAuthor(auth)
795        return auth
796
797    def _process(self):
798        params=self._getRequestParams()
799        if "selectedPrincipals" in params and not "cancel" in params:
800            ah=user.AvatarHolder()
801            authIndex = self._target.getConference().getAuthorIndex()
802            for id in self._normaliseListParam(params["selectedPrincipals"]):
803                if id[:9] == "*author*:":
804                    id = id[9:]
805                    auth=self._newPrimAuthorFromAuthor(authIndex.getById(id)[0])
806                else:
807                    auth=self._newPrimAuthor(ah.getById(id))
808                if self._getRequestParams().has_key("submissionControl"):
809                    self._target.grantSubmission(auth)
810        self._redirect(urlHandlers.UHContributionModification.getURL(self._target))
811
812class RHSearchCoAuthor (RHContribModifBaseSpecialSesCoordRights):
813    def _process(self):
814        p=contributions.WPModSearchCoAuthor(self, self._target)
815        return p.display(**self._getRequestParams())
816
817class RHSearchAddCoAuthor (RHContribModifBaseSpecialSesCoordRights):
818
819    def _newCoAuthor(self, a):
820        auth = conference.ContributionParticipation()
821        p = self._getRequestParams()
822        auth.setTitle(a.getTitle())
823        auth.setFirstName(a.getName())
824        auth.setFamilyName(a.getSurName())
825        auth.setAffiliation(a.getOrganisation())
826        auth.setEmail(a.getEmail())
827        auth.setAddress(a.getAddress())
828        auth.setPhone(a.getTelephone())
829        auth.setFax(a.getFax())
830        self._target.addCoAuthor(auth)
831        return auth
832
833    def _newCoAuthorFromAuthor(self, a):
834        auth = conference.ContributionParticipation()
835        p = self._getRequestParams()
836        auth.setTitle(a.getTitle())
837        auth.setFirstName(a.getName())
838        auth.setFamilyName(a.getSurName())
839        auth.setAffiliation(a.getAffiliation())
840        auth.setEmail(a.getEmail())
841        auth.setAddress(a.getAddress())
842        auth.setPhone(a.getPhone())
843        auth.setFax(a.getFax())
844        self._target.addCoAuthor(auth)
845        return auth
846
847    def _process(self):
848        params=self._getRequestParams()
849        if "selectedPrincipals" in params and not "cancel" in params:
850            ah=user.AvatarHolder()
851            authIndex = self._target.getConference().getAuthorIndex()
852            for id in self._normaliseListParam(params["selectedPrincipals"]):
853                if id[:9] == "*author*:":
854                    id = id[9:]
855                    auth=self._newCoAuthorFromAuthor(authIndex.getById(id)[0])
856                else:
857                    auth=self._newCoAuthor(ah.getById(id))
858                if self._getRequestParams().has_key("submissionControl"):
859                    self._target.grantSubmission(auth)
860        self._redirect(urlHandlers.UHContributionModification.getURL(self._target))
861
862
863class RHSearchSpeakers (RHContribModifBaseSpecialSesCoordRights):
864    def _process(self):
865        p=contributions.WPModSearchSpeaker(self, self._target)
866        return p.display(**self._getRequestParams())
867
868class RHSearchAddSpeakers (RHContribModifBaseSpecialSesCoordRights):
869
870    def _newSpeaker(self, a):
871        auth = conference.ContributionParticipation()
872        p = self._getRequestParams()
873        auth.setTitle(a.getTitle())
874        auth.setFirstName(a.getName())
875        auth.setFamilyName(a.getSurName())
876        auth.setAffiliation(a.getOrganisation())
877        auth.setEmail(a.getEmail())
878        auth.setAddress(a.getAddress())
879        auth.setPhone(a.getTelephone())
880        auth.setFax(a.getFax())
881        self._target.newSpeaker(auth)
882        return auth
883
884    def _newSpeakerFromAuthor(self, a):
885        auth = conference.ContributionParticipation()
886        p = self._getRequestParams()
887        auth.setTitle(a.getTitle())
888        auth.setFirstName(a.getName())
889        auth.setFamilyName(a.getSurName())
890        auth.setAffiliation(a.getAffiliation())
891        auth.setEmail(a.getEmail())
892        auth.setAddress(a.getAddress())
893        auth.setPhone(a.getPhone())
894        auth.setFax(a.getFax())
895        self._target.newSpeaker(auth)
896        return auth
897
898    def _process(self):
899        params=self._getRequestParams()
900        if "selectedPrincipals" in params and not "cancel" in params:
901            ah=user.AvatarHolder()
902            authIndex = self._target.getConference().getAuthorIndex()
903            for id in self._normaliseListParam(params["selectedPrincipals"]):
904                if id[:9] == "*author*:":
905                    id = id[9:]
906                    auth=self._newSpeakerFromAuthor(authIndex.getById(id)[0])
907                else:
908                    auth=self._newSpeaker(ah.getById(id))
909                if self._getRequestParams().has_key("submissionControl"):
910                    self._target.grantSubmission(auth)
911        self._redirect(urlHandlers.UHContributionModification.getURL(self._target))
912
913class RHNewPrimaryAuthor(RHContribModifBaseSpecialSesCoordRights):
914
915    def _checkParams(self, params):
916        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
917        self._action, self._new="", False
918        if params.has_key("ok"):
919            self._action = "perform"
920        elif params.has_key("ok_and_new"):
921            self._action = "perform"
922            self._new=True
923        elif params.has_key("cancel"):
924            self._action = "cancel"
925
926    def _newPrimAuthor(self):
927        auth = conference.ContributionParticipation()
928        p = self._getRequestParams()
929        auth.setTitle(p.get("title", ""))
930        auth.setFirstName(p.get("name", ""))
931        auth.setFamilyName(p.get("surName", ""))
932        auth.setAffiliation(p.get("affiliation", ""))
933        auth.setEmail(p.get("email", ""))
934        auth.setAddress(p.get("address", ""))
935        auth.setPhone(p.get("phone", ""))
936        auth.setFax(p.get("fax", ""))
937        self._target.addPrimaryAuthor(auth)
938        return auth
939
940
941    def _process(self):
942        url=urlHandlers.UHContributionModification.getURL(self._target)
943        if self._action=="cancel":
944            self._redirect(url)
945            return
946        elif self._action == "perform":
947            auth=self._newPrimAuthor()
948            if self._getRequestParams().has_key("submissionControl"):
949                if self._getRequestParams().get("email", "").strip() == "":
950                    raise FormValuesError("If you want to add the author as submitter, please enter their email")
951                self._target.grantSubmission(auth)
952            if not self._new:
953                self._redirect(url)
954                return
955        p = contributions.WPModNewPrimAuthor(self, self._target)
956        return p.display()
957
958
959class RHPrimaryAuthorsActions:
960    """
961    class to select the action to do with the selected authors
962    """
963    def __init__(self, req):
964        self._req = req
965
966    def process(self, params):
967        if params.has_key("REMOVE"):
968            return RHRemPrimaryAuthors(self._req).process(params)
969        elif params.has_key("MOVE"):
970            return RHMovePrimaryToCoAuthors(self._req).process(params)
971        return "no action to do"
972
973
974class RHRemPrimaryAuthors(RHContribModifBaseSpecialSesCoordRights):
975    def _checkParams(self, params):
976        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
977        self._list = []
978        for id in self._normaliseListParam(params.get("selAuthor", [])):
979            self._list.append(self._target.getAuthorById(id))
980
981    def _process(self):
982        for auth in self._list:
983            self._target.removePrimaryAuthor(auth)
984        url=urlHandlers.UHContributionModification.getURL(self._target)
985        self._redirect(url)
986
987class RHMovePrimaryToCoAuthors(RHContribModifBaseSpecialSesCoordRights):
988    def _checkParams(self, params):
989        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
990        self._list = []
991        for id in self._normaliseListParam(params.get("selAuthor", [])):
992            self._list.append(self._target.getAuthorById(id))
993
994    def _process(self):
995        for auth in self._list:
996            self._target.removePrimaryAuthor(auth, 0, False)
997            self._target.addCoAuthor(auth)
998        url=urlHandlers.UHContributionModification.getURL(self._target)
999        self._redirect(url)
1000
1001
1002class RHEditPrimaryAuthor(RHContribModifBaseSpecialSesCoordRights):
1003
1004    def _checkParams(self, params):
1005        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1006        self._authorId=params["authorId"]
1007        self._action=""
1008        if params.has_key("ok"):
1009            self._action = "perform"
1010        elif params.has_key("cancel"):
1011            self._action = "cancel"
1012
1013    def _setPrimAuthorData(self):
1014        auth=self._target.getAuthorById(self._authorId)
1015        p = self._getRequestParams()
1016        auth.setTitle(p.get("title", ""))
1017        auth.setFirstName(p.get("name", ""))
1018        auth.setFamilyName(p.get("surName", ""))
1019        auth.setAffiliation(p.get("affiliation", ""))
1020        auth.setAddress(p.get("address", ""))
1021        auth.setPhone(p.get("phone", ""))
1022        auth.setFax(p.get("fax", ""))
1023
1024        grantSubm=False
1025        if auth.getEmail().lower().strip() != p.get("email", "").lower().strip():
1026            #----If it's already in the pending queue in order to grant
1027            #    submission rights we must unindex and after the modification of the email,
1028            #    index again...
1029            if self._target.getConference().getPendingQueuesMgr().isPendingSubmitter(auth):
1030                self._target.getConference().getPendingQueuesMgr().removePendingSubmitter(auth)
1031                grantSubm=True
1032            #-----
1033
1034        auth.setEmail(p.get("email", ""))
1035
1036        if grantSubm:
1037            self._target.grantSubmission(auth)
1038
1039    def _process(self):
1040        if self._action != "":
1041            if self._action == "perform":
1042                self._setPrimAuthorData()
1043            url=urlHandlers.UHContributionModification.getURL(self._target)
1044            self._redirect(url)
1045        else:
1046            auth=self._target.getAuthorById(self._authorId)
1047            p = contributions.WPModPrimAuthor(self, self._target)
1048            return p.display(author=auth)
1049
1050
1051class RHNewCoAuthor(RHContribModifBaseSpecialSesCoordRights):
1052
1053    def _checkParams(self, params):
1054        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1055        self._action, self._new="", False
1056        if params.has_key("ok"):
1057            self._action = "perform"
1058        elif params.has_key("ok_and_new"):
1059            self._action = "perform"
1060            self._new=True
1061        elif params.has_key("cancel"):
1062            self._action = "cancel"
1063
1064    def _newCoAuthor(self):
1065        auth = conference.ContributionParticipation()
1066        p = self._getRequestParams()
1067        auth.setTitle(p.get("title", ""))
1068        auth.setFirstName(p.get("name", ""))
1069        auth.setFamilyName(p.get("surName", ""))
1070        auth.setAffiliation(p.get("affiliation", ""))
1071        auth.setEmail(p.get("email", ""))
1072        auth.setAddress(p.get("address", ""))
1073        auth.setPhone(p.get("phone", ""))
1074        auth.setFax(p.get("fax", ""))
1075        self._target.addCoAuthor(auth)
1076        return auth
1077
1078    def _process(self):
1079        url=urlHandlers.UHContributionModification.getURL(self._target)
1080        if self._action=="cancel":
1081            self._redirect(url)
1082            return
1083        elif self._action=="perform":
1084            auth=self._newCoAuthor()
1085            if self._getRequestParams().has_key("submissionControl"):
1086                if self._getRequestParams().get("email", "").strip() == "":
1087                    raise FormValuesError("If you want to add the author as submitter, please enter their email")
1088                self._target.grantSubmission(auth)
1089            if not self._new:
1090                self._redirect(url)
1091                return
1092        p=contributions.WPModNewCoAuthor(self, self._target)
1093        return p.display()
1094
1095
1096class RHCoAuthorsActions:
1097    """
1098    class to select the action to do with the selected authors
1099    """
1100    def __init__(self, req):
1101        self._req = req
1102
1103    def process(self, params):
1104        if params.has_key("REMOVE"):
1105            return RHRemCoAuthors(self._req).process(params)
1106        elif params.has_key("MOVE"):
1107            return RHMoveCoToPrimaryAuthors(self._req).process(params)
1108        return "no action to do"
1109
1110
1111class RHRemCoAuthors(RHContribModifBaseSpecialSesCoordRights):
1112
1113    def _checkParams(self, params):
1114        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1115        self._list = []
1116        for id in self._normaliseListParam(params.get("selAuthor", [])):
1117            self._list.append(self._target.getAuthorById(id))
1118
1119    def _process(self):
1120        for auth in self._list:
1121            self._target.removeCoAuthor(auth)
1122        url=urlHandlers.UHContributionModification.getURL(self._target)
1123        self._redirect(url)
1124
1125class RHMoveCoToPrimaryAuthors(RHContribModifBaseSpecialSesCoordRights):
1126    def _checkParams(self, params):
1127        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1128        self._list = []
1129        for id in self._normaliseListParam(params.get("selAuthor", [])):
1130            self._list.append(self._target.getAuthorById(id))
1131
1132    def _process(self):
1133        for auth in self._list:
1134            self._target.removeCoAuthor(auth, 0, False)
1135            self._target.addPrimaryAuthor(auth)
1136        url=urlHandlers.UHContributionModification.getURL(self._target)
1137        self._redirect(url)
1138
1139class RHEditCoAuthor(RHContribModifBaseSpecialSesCoordRights):
1140
1141    def _checkParams(self, params):
1142        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1143        self._authorId=params["authorId"]
1144        self._action=""
1145        if params.has_key("ok"):
1146            self._action = "perform"
1147        elif params.has_key("cancel"):
1148            self._action = "cancel"
1149
1150    def _setCoAuthorData(self):
1151        auth=self._target.getAuthorById(self._authorId)
1152        p = self._getRequestParams()
1153        auth.setTitle(p.get("title", ""))
1154        auth.setFirstName(p.get("name", ""))
1155        auth.setFamilyName(p.get("surName", ""))
1156        auth.setAffiliation(p.get("affiliation", ""))
1157        auth.setAddress(p.get("address", ""))
1158        auth.setPhone(p.get("phone", ""))
1159        auth.setFax(p.get("fax", ""))
1160
1161        grantSubm=False
1162        if auth.getEmail().lower().strip() != p.get("email", "").lower().strip():
1163            #----If it's already in the pending queue in order to grant
1164            #    submission rights we must unindex and after the modification of the email,
1165            #    index again...
1166            if self._target.getConference().getPendingQueuesMgr().isPendingSubmitter(auth):
1167                self._target.getConference().getPendingQueuesMgr().removePendingSubmitter(auth)
1168                grantSubm=True
1169            #-----
1170
1171        auth.setEmail(p.get("email", ""))
1172
1173        if grantSubm:
1174            self._target.grantSubmission(auth)
1175
1176    def _process(self):
1177        if self._action != "":
1178            if self._action == "perform":
1179                self._setCoAuthorData()
1180            url=urlHandlers.UHContributionModification.getURL(self._target)
1181            self._redirect(url)
1182        else:
1183            auth=self._target.getAuthorById(self._authorId)
1184            p = contributions.WPModCoAuthor(self, self._target)
1185            return p.display(author=auth)
1186
1187
1188class RHRemSpeakers(RHContribModifBaseSpecialSesCoordRights):
1189
1190    def _checkParams(self, params):
1191        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1192        self._list = []
1193        for id in self._normaliseListParam(params.get("selSpeaker", [])):
1194            self._list.append(self._target.getSpeakerById(id))
1195
1196    def _process(self):
1197        for auth in self._list:
1198            if auth is None:
1199                continue
1200            self._target.removeSpeaker(auth)
1201        url=urlHandlers.UHContributionModification.getURL(self._target)
1202        self._redirect(url)
1203
1204
1205class RHAddSpeakers(RHContribModifBaseSpecialSesCoordRights):
1206
1207    def _checkParams(self, params):
1208        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1209        self._list = []
1210        for id in self._normaliseListParam(params.get("selAuthor", [])):
1211            self._list.append(self._target.getAuthorById(id))
1212
1213    def _process(self):
1214        for auth in self._list:
1215            if auth is None:
1216                continue
1217            self._target.addSpeaker(auth)
1218        url=urlHandlers.UHContributionModification.getURL(self._target)
1219        self._redirect(url)
1220
1221
1222class RHSetTrack(RHContribModifBase):
1223
1224    def _checkParams(self, params):
1225        RHContribModifBase._checkParams(self, params)
1226        self._track=None
1227        if params.has_key("selTrack") and params["selTrack"].strip() != "":
1228            self._track = self._target.getConference().getTrackById(params["selTrack"])
1229
1230    def _process(self):
1231        self._target.setTrack(self._track)
1232        url=urlHandlers.UHContributionModification.getURL(self._target)
1233        self._redirect(url)
1234
1235
1236class RHSetSession(RHContribModifBase):
1237
1238    def _checkParams(self, params):
1239        RHContribModifBase._checkParams(self, params)
1240        self._session=None
1241        if params.has_key("selSession") and params["selSession"].strip() != "":
1242            self._session=self._target.getConference().getSessionById(params["selSession"])
1243
1244    def _process(self):
1245        self._target.setSession(self._session)
1246        url=urlHandlers.UHContributionModification.getURL(self._target)
1247        self._redirect(url)
1248
1249
1250#class RHContributionSelectSpeakers( RHContribModifBase ):
1251#    _uh = urlHandlers.UHContributionSelectSpeakers
1252#
1253#    def _process( self ):
1254#        p = contributions.WPcontribSelectChairs( self, self._target )
1255#        return p.display( **self._getRequestParams() )
1256#
1257#
1258#class RHContributionAddSpeakers( RHContribModifBase ):
1259#    _uh = urlHandlers.UHContributionAddSpeakers
1260#
1261#    def _checkParams( self, params ):
1262#        RHContribModifBase._checkParams( self, params )
1263#        selSpeakerId = self._normaliseListParam( params.get( "selectedPrincipals", [] ) )
1264#        ah = user.AvatarHolder()
1265#        self._speakers = []
1266#        for id in selSpeakerId:
1267#            self._speakers.append( ah.getById( id ) )
1268#
1269#    def _process( self ):
1270#        for av in self._speakers:
1271#            self._target.addSpeaker( av )
1272#        self._redirect( urlHandlers.UHContributionModification.getURL( self._target ) )
1273#
1274#
1275#class RHContributionRemoveSpeakers( RHContribModifBase ):
1276#    _uh = urlHandlers.UHContributionRemoveSpeakers
1277#
1278#    def _checkParams( self, params ):
1279#        RHContribModifBase._checkParams( self, params )
1280#        selSpeakerId = self._normaliseListParam( params.get( "selectedPrincipals", [] ) )
1281#        ah = user.AvatarHolder()
1282#        self._speakers = []
1283#        for id in selSpeakerId:
1284#            self._speakers.append( ah.getById( id ) )
1285#
1286#    def _process( self ):
1287#        for av in self._speakers:
1288#            self._target.removeSpeaker( av )
1289#        self._redirect( urlHandlers.UHContributionModification.getURL( self._target ) )
1290
1291
1292class RHContributionAddMaterial(RHContribModifBaseSpecialSesCoordRights):
1293    _uh = urlHandlers.UHContributionAddMaterial
1294
1295    def _checkParams(self, params):
1296        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1297        typeMat = params.get("typeMaterial", "notype")
1298        if typeMat=="notype" or typeMat.strip()=="":
1299            raise FormValuesError("Please choose a material type")
1300        self._mf = materialFactories.ContribMFRegistry().getById(typeMat)
1301
1302    def _process(self):
1303        if self._mf:
1304            if not self._mf.needsCreationPage():
1305                m = RHContributionPerformAddMaterial.create(self._target, self._mf, self._getRequestParams())
1306                self._redirect(urlHandlers.UHMaterialModification.getURL(m))
1307                return
1308        p = contributions.WPContribAddMaterial(self, self._target, self._mf)
1309        wf = self.getWebFactory()
1310        if wf != None:
1311            p = wf.getContribAddMaterial(self, self._target, self._mf)
1312        return p.display()
1313
1314
1315class RHContributionPerformAddMaterial(RHContribModifBaseSpecialSesCoordRights):
1316    _uh = urlHandlers.UHContributionPerformAddMaterial
1317
1318    def _checkParams(self, params):
1319        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1320        typeMat = params.get("typeMaterial", "")
1321        self._mf = materialFactories.ContribMFRegistry.getById(typeMat)
1322
1323    @staticmethod
1324    def create(contrib, matFactory, matData):
1325        if matFactory:
1326            m = matFactory.create(contrib)
1327        else:
1328            m = conference.Material()
1329            contrib.addMaterial(m)
1330            m.setValues(matData)
1331        return m
1332
1333    def _process(self):
1334        m = self.create(self._target, self._mf, self._getRequestParams())
1335        self._redirect(urlHandlers.UHMaterialModification.getURL(m))
1336
1337
1338class RHContributionRemoveMaterials(RHContribModifBaseSpecialSesCoordRights):
1339    _uh = urlHandlers.UHContributionRemoveMaterials
1340
1341    def _checkParams(self, params):
1342        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1343        #typeMat = params.get( "typeMaterial", "" )
1344        #self._mf = materialFactories.ConfMFRegistry().getById( typeMat )
1345        self._materialIds = self._normaliseListParam(params.get("deleteMaterial", []))
1346        self._materialIds = self._normaliseListParam( params.get("materialId", []) )
1347        self._returnURL = params.get("returnURL","")
1348
1349    def _process(self):
1350        for id in self._materialIds:
1351            #Performing the deletion of special material types
1352            f = materialFactories.ContribMFRegistry().getById(id)
1353            if f:
1354                f.remove(self._target)
1355            else:
1356                #Performs the deletion of additional material types
1357                mat = self._target.getMaterialById( id )
1358                self._target.removeMaterial( mat )
1359        if self._returnURL != "":
1360            url = self._returnURL
1361        else:
1362            url = urlHandlers.UHContribModifMaterials.getURL( self._target )
1363        self._redirect( url )
1364
1365
1366class RHMaterialsAdd(RHContribModifBaseSpecialSesCoordRights):
1367    _uh = urlHandlers.UHContribModifAddMaterials
1368
1369    def _checkProtection(self):
1370        material, _ = self._rhSubmitMaterial._getMaterial(forceCreate = False)
1371        if self._target.canUserSubmit(self._aw.getUser()) \
1372            and (not material or material.getReviewingState() < 3):
1373            return
1374        if not (RCContributionPaperReviewingStaff.hasRights(self) and not self._target.getReviewManager().getLastReview().isAuthorSubmitted()):
1375            RHContribModifBaseSpecialSesCoordRights._checkProtection(self)
1376
1377    def _checkParams(self, params):
1378        RHContribModifBase._checkParams(self, params)
1379        if not hasattr(self,"_rhSubmitMaterial"):
1380            self._rhSubmitMaterial=RHSubmitMaterialBase(self._target, self)
1381        self._rhSubmitMaterial._checkParams(params)
1382
1383    def _process( self ):
1384        if self._target.getConference().isClosed():
1385            p = WPConferenceModificationClosed( self, self._target )
1386            return p.display()
1387        else:
1388            r=self._rhSubmitMaterial._process(self, self._getRequestParams())
1389        if r is None:
1390            self._redirect(self._uh.getURL(self._target))
1391
1392        return r
1393
1394class RHContributionSelectManagers(RHContribModifBaseSpecialSesCoordRights):
1395    _uh = urlHandlers.UHContributionSelectManagers
1396
1397    def _process(self):
1398        p = contributions.WPContributionSelectManagers(self, self._target)
1399        return p.display(**self._getRequestParams())
1400
1401
1402class RHContributionAddManagers(RHContribModifBaseSpecialSesCoordRights):
1403    _uh = urlHandlers.UHContributionAddManagers
1404
1405    def _process(self):
1406        params = self._getRequestParams()
1407        if "selectedPrincipals" in params and not "cancel" in params:
1408            ph = user.PrincipalHolder()
1409            for id in self._normaliseListParam(params["selectedPrincipals"]):
1410                self._target.grantModification(ph.getById(id))
1411        self._redirect(urlHandlers.UHContribModifAC.getURL(self._target))
1412
1413
1414class RHContributionRemoveManagers(RHContribModifBaseSpecialSesCoordRights):
1415    _uh = urlHandlers.UHContributionRemoveManagers
1416
1417    def _process(self):
1418        params = self._getRequestParams()
1419        if ("selectedPrincipals" in params) and \
1420            (len(params["selectedPrincipals"])!=0):
1421            ph = user.PrincipalHolder()
1422            for id in self._normaliseListParam(params["selectedPrincipals"]):
1423                self._target.revokeModification(ph.getById(id))
1424        self._redirect(urlHandlers.UHContribModifAC.getURL(self._target))
1425
1426
1427class RHContributionSetVisibility(RHContribModifBaseSpecialSesCoordRights):
1428    _uh = urlHandlers.UHContributionSetVisibility
1429
1430    def _process(self):
1431        params = self._getRequestParams()
1432        privacy = params.get("visibility","INHERITING")
1433        self._protect = 0
1434        if privacy == "PRIVATE":
1435            self._protect = 1
1436        elif privacy == "INHERITING":
1437            self._protect = 0
1438        elif privacy == "PUBLIC":
1439            self._protect = -1
1440        self._target.setProtection(self._protect)
1441        self._redirect(urlHandlers.UHContribModifAC.getURL(self._target))
1442
1443
1444class RHContributionSelectAllowed(RHContribModifBaseSpecialSesCoordRights):
1445    _uh = urlHandlers.UHContributionSelectAllowed
1446
1447    def _process(self):
1448        p = contributions.WPContributionSelectAllowed(self, self._target)
1449        return p.display(**self._getRequestParams())
1450
1451
1452class RHContributionAddAllowed(RHContribModifBaseSpecialSesCoordRights):
1453    _uh = urlHandlers.UHContributionAddAllowed
1454
1455    def _process(self):
1456        params = self._getRequestParams()
1457        if "selectedPrincipals" in params and not "cancel" in params:
1458            ph = user.PrincipalHolder()
1459            for id in self._normaliseListParam(params["selectedPrincipals"]):
1460                self._target.grantAccess(ph.getById(id))
1461        self._redirect(urlHandlers.UHContribModifAC.getURL(self._target))
1462
1463
1464class RHContributionRemoveAllowed(RHContribModifBaseSpecialSesCoordRights):
1465    _uh = urlHandlers.UHContributionRemoveAllowed
1466
1467    def _process(self):
1468        params = self._getRequestParams()
1469        if ("selectedPrincipals" in params) and \
1470            (len(params["selectedPrincipals"])!=0):
1471            ph = user.PrincipalHolder()
1472            for id in self._normaliseListParam(params["selectedPrincipals"]):
1473                self._target.revokeAccess(ph.getById(id))
1474        self._redirect(urlHandlers.UHContribModifAC.getURL(self._target))
1475
1476
1477class RHContributionAddDomains(RHContribModifBaseSpecialSesCoordRights):
1478    _uh = urlHandlers.UHContributionAddDomain
1479
1480    def _process(self):
1481        params = self._getRequestParams()
1482        if ("addDomain" in params) and (len(params["addDomain"])!=0):
1483            dh = domain.DomainHolder()
1484            for domId in self._normaliseListParam(params["addDomain"]):
1485                self._target.requireDomain(dh.getById(domId))
1486        self._redirect(urlHandlers.UHContribModifAC.getURL(self._target))
1487
1488
1489class RHContributionRemoveDomains(RHContribModifBaseSpecialSesCoordRights):
1490    _uh = urlHandlers.UHContributionRemoveDomain
1491
1492    def _process(self):
1493        params = self._getRequestParams()
1494        if ("selectedDomain" in params) and (len(params["selectedDomain"])!=0):
1495            dh = domain.DomainHolder()
1496            for domId in self._normaliseListParam(params["selectedDomain"]):
1497                self._target.freeDomain(dh.getById(domId))
1498        #self._endRequest()
1499        self._redirect(urlHandlers.UHContribModifAC.getURL(self._target))
1500
1501
1502class RHContributionDeletion(RHContribModifBaseSpecialSesCoordRights):
1503    _uh = urlHandlers.UHContributionDelete
1504
1505    def _checkParams(self, params):
1506        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1507        self._cancel = False
1508        if "cancel" in params:
1509            self._cancel = True
1510        self._confirmation = params.has_key("confirm")
1511
1512    def _perform(self):
1513        conf = self._target.getConference()
1514        self._target.getOwner().getSchedule().removeEntry(self._target.getSchEntry())
1515        #self._target.getOwner().removeContribution(self._target)
1516        self._target.delete()
1517        #conf.removeContribution(self._target)
1518
1519    def _process(self):
1520        if self._cancel:
1521            self._redirect(urlHandlers.UHContribModifTools.getURL(self._target))
1522        elif self._confirmation:
1523            owner = self._target.getOwner()
1524            self._perform()
1525            if self._target.getSession():
1526                self._redirect(urlHandlers.UHsessionModification.getURL(owner))
1527            else:
1528                self._redirect(urlHandlers.UHConferenceModification.getURL(owner))
1529        else:
1530            p = contributions.WPContributionDeletion(self, self._target)
1531            return p.display()
1532
1533
1534class RHContributionMove(RHContribModifBaseSpecialSesCoordRights):
1535    _uh = urlHandlers.UHContributionMove
1536
1537    def _process(self):
1538        p = contributions.WPcontribMove(self, self._target)
1539        return p.display(**self._getRequestParams())
1540
1541
1542class RHContributionPerformMove(RHContribModifBaseSpecialSesCoordRights):
1543    _uh = urlHandlers.UHContributionPerformMove
1544
1545    def _checkParams(self, params):
1546        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1547        self._dest = params["Destination"]
1548
1549    def _process(self):
1550        conf = self._target.getConference()
1551        if self._dest == 'CONF':
1552            newOwner = conf
1553        else:
1554            newOwner = conf.getSessionById(self._dest)
1555        self._moveContrib(newOwner)
1556        self._redirect(urlHandlers.UHContribModifTools.getURL(self._target))
1557
1558        return "done"
1559
1560    def _moveContrib(self, newOwner):
1561        owner = self._target.getOwner()
1562        owner.removeContribution(self._target)
1563        newOwner.addContribution(self._target)
1564
1565
1566class RHContributionWriteMinutes(RHContribModifBaseSpecialSesCoordRights):
1567    _uh = urlHandlers.UHContributionWriteMinutes
1568
1569    def _checkParams(self, params):
1570        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1571        self._cancel = params.has_key("cancel")
1572        self._save = params.has_key("OK")
1573        self._text = params.get("text", "")#.strip()
1574
1575    def _process(self):
1576        if self._cancel:
1577            self._redirect(urlHandlers.UHContribModifTools.getURL(self._target))
1578        elif self._save:
1579            #if self._text!="":
1580                minutes = self._target.getMinutes()
1581                if not minutes:
1582                    minutes = self._target.createMinutes()
1583                minutes.setText(self._text)
1584                self._redirect(urlHandlers.UHContribModifTools.getURL(self._target))
1585        else:
1586            p = contributions.WPContributionWriteMinutes(self, self._target)
1587            return p.display()
1588
1589class RHContributionToXML(RHContributionModification):
1590    _uh = urlHandlers.UHContribToXMLConfManager
1591
1592    def _process(self):
1593        filename = "%s - contribution.xml"%self._target.getTitle()
1594        x = XMLGen()
1595        x.openTag("contribution")
1596        x.writeTag("Id", self._target.getId())
1597        x.writeTag("Title", self._target.getTitle())
1598        x.writeTag("Description", self._target.getDescription())
1599        afm = self._target.getConference().getAbstractMgr().getAbstractFieldsMgr()
1600        for f in afm.getFields():
1601            id = f.getId()
1602            if f.isActive() and self._target.getField(id).strip() != "":
1603                x.writeTag(f.getName().replace(" ","_"),self._target.getField(id))
1604        x.writeTag("Conference", self._target.getConference().getTitle())
1605        session = self._target.getSession()
1606        if session!=None:
1607            x.writeTag("Session", self._target.getSession().getTitle())
1608        l = []
1609        for au in self._target.getAuthorList():
1610            if self._target.isPrimaryAuthor(au):
1611                x.openTag("PrimaryAuthor")
1612                x.writeTag("FirstName", au.getFirstName())
1613                x.writeTag("FamilyName", au.getFamilyName())
1614                x.writeTag("Email", au.getEmail())
1615                x.writeTag("Affiliation", au.getAffiliation())
1616                x.closeTag("PrimaryAuthor")
1617            else:
1618                l.append(au)
1619
1620        for au in l:
1621            x.openTag("Co-Author")
1622            x.writeTag("FirstName", au.getFirstName())
1623            x.writeTag("FamilyName", au.getFamilyName())
1624            x.writeTag("Email", au.getEmail())
1625            x.writeTag("Affiliation", au.getAffiliation())
1626            x.closeTag("Co-Author")
1627
1628        for au in self._target.getSpeakerList():
1629            x.openTag("Speaker")
1630            x.writeTag("FirstName", au.getFirstName ())
1631            x.writeTag("FamilyName", au.getFamilyName())
1632            x.writeTag("Email", au.getEmail())
1633            x.writeTag("Affiliation", au.getAffiliation())
1634            x.closeTag("Speaker")
1635
1636        #To change for the new contribution type system to:
1637        typeName = ""
1638        if self._target.getType():
1639            typeName = self._target.getType().getName()
1640        x.writeTag("ContributionType", typeName)
1641
1642        t = self._target.getTrack()
1643        if t!=None:
1644            x.writeTag("Track", t.getTitle())
1645
1646        x.closeTag("contribution")
1647
1648        data = x.getXml()
1649
1650        cfg = Config.getInstance()
1651        mimetype = cfg.getFileTypeMimeType("XML")
1652        self._req.content_type = """%s"""%(mimetype)
1653        self._req.headers_out["Content-Length"] = "%s"%len(data)
1654        self._req.headers_out["Content-Disposition"] = """inline; filename="%s\""""%filename
1655        return data
1656
1657
1658class RHContributionToPDF(RHContributionModification):
1659    _uh = urlHandlers.UHContribToPDFConfManager
1660
1661    def _process(self):
1662        tz = self._target.getConference().getTimezone()
1663        filename = "%s - Contribution.pdf"%self._target.getTitle()
1664        pdf = ConfManagerContribToPDF(self._target.getConference(), self._target, tz=tz)
1665        data = pdf.getPDFBin()
1666        self._req.headers_out["Content-Length"] = "%s"%len(data)
1667        cfg = Config.getInstance()
1668        mimetype = cfg.getFileTypeMimeType("PDF")
1669        self._req.content_type = """%s"""%(mimetype)
1670        self._req.headers_out["Content-Disposition"] = """inline; filename="%s\""""%filename
1671        return data
1672
1673
1674class RHAuthBase(RHContribModifBaseSpecialSesCoordRights):
1675
1676    def _checkParams(self, params):
1677        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1678        self._auth=self._target.getAuthorById(params.get("authId", ""))
1679
1680
1681class RHPrimAuthUp(RHAuthBase):
1682
1683    def _process(self):
1684        contrib=self._target
1685        contrib.upPrimaryAuthor(self._auth)
1686        self._redirect(urlHandlers.UHContributionModification.getURL(contrib))
1687
1688
1689class RHPrimAuthDown(RHAuthBase):
1690
1691    def _process(self):
1692        contrib=self._target
1693        contrib.downPrimaryAuthor(self._auth)
1694        self._redirect(urlHandlers.UHContributionModification.getURL(contrib))
1695
1696
1697class RHCoAuthUp(RHAuthBase):
1698
1699    def _process(self):
1700        contrib=self._target
1701        contrib.upCoAuthor(self._auth)
1702        self._redirect(urlHandlers.UHContributionModification.getURL(contrib))
1703
1704
1705class RHCoAuthDown(RHAuthBase):
1706
1707    def _process(self):
1708        contrib=self._target
1709        contrib.downCoAuthor(self._auth)
1710        self._redirect(urlHandlers.UHContributionModification.getURL(contrib))
1711
1712class RHNewSpeaker(RHContribModifBaseSpecialSesCoordRights):
1713
1714    def _checkParams(self, params):
1715        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1716        self._action=""
1717        if params.has_key("ok"):
1718            self._action = "perform"
1719        elif params.has_key("cancel"):
1720            self._action = "cancel"
1721
1722    def _newSpeaker(self):
1723        auth = conference.ContributionParticipation()
1724        p = self._getRequestParams()
1725        auth.setTitle(p.get("title", ""))
1726        auth.setFirstName(p.get("name", ""))
1727        auth.setFamilyName(p.get("surName", ""))
1728        auth.setAffiliation(p.get("affiliation", ""))
1729        auth.setEmail(p.get("email", ""))
1730        auth.setAddress(p.get("address", ""))
1731        auth.setPhone(p.get("phone", ""))
1732        auth.setFax(p.get("fax", ""))
1733        self._target.newSpeaker(auth)
1734        return auth
1735
1736    def _process(self):
1737        if self._action != "":
1738            if self._action == "perform":
1739                auth=self._newSpeaker()
1740                if self._getRequestParams().has_key("submissionControl"):
1741                    if self._getRequestParams().get("email", "").strip() != "":
1742                        #raise FormValuesError("If you want to add the author as submitter, please enter their email")
1743                        self._target.grantSubmission(auth)
1744            url=urlHandlers.UHContributionModification.getURL(self._target)
1745            self._redirect(url)
1746        else:
1747            p = contributions.WPModNewSpeaker(self, self._target)
1748            wf = self.getWebFactory()
1749            if wf != None:
1750                p = wf.getContributionNewspeaker(self, self._target)
1751            return p.display()
1752
1753class RHEditSpeaker(RHContribModifBaseSpecialSesCoordRights):
1754
1755    def _checkParams(self, params):
1756        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1757        self._authorId=params["authorId"]
1758        self._action=""
1759        if params.has_key("ok"):
1760            self._action = "perform"
1761        elif params.has_key("cancel"):
1762            self._action = "cancel"
1763
1764    def _setSpeakerData(self):
1765        auth=self._target.getSpeakerById(self._authorId)
1766        if auth is not None:
1767            p = self._getRequestParams()
1768            auth.setTitle(p.get("title", ""))
1769            auth.setFirstName(p.get("name", ""))
1770            auth.setFamilyName(p.get("surName", ""))
1771            auth.setAffiliation(p.get("affiliation", ""))
1772            auth.setAddress(p.get("address", ""))
1773            auth.setPhone(p.get("phone", ""))
1774            auth.setFax(p.get("fax", ""))
1775
1776            grantSubm=False
1777            if auth.getEmail().lower().strip() != p.get("email", "").lower().strip():
1778                #----If it's already in the pending queue in order to grant
1779                #    submission rights we must unindex and after the modification of the email,
1780                #    index again...
1781                if self._target.getConference().getPendingQueuesMgr().isPendingSubmitter(auth):
1782                    self._target.getConference().getPendingQueuesMgr().removePendingSubmitter(auth)
1783                    grantSubm=True
1784                #-----
1785
1786            auth.setEmail(p.get("email", ""))
1787
1788            if grantSubm:
1789                if p.get("email", "").strip() == "":
1790                    raise FormValuesError("This speaker is in a pending queue waiting to become submitter therefore the email address cannot be empty, please enter their email")
1791                self._target.grantSubmission(auth)
1792            elif p.has_key("submissionControl"):
1793                if p.get("email", "").strip() == "":
1794                    raise FormValuesError("If you want to add the speaker as submitter, please enter their email")
1795                self._target.grantSubmission(auth)
1796
1797    def _process(self):
1798        if self._action != "":
1799            if self._action == "perform":
1800                self._setSpeakerData()
1801            url=urlHandlers.UHContributionModification.getURL(self._target)
1802            self._redirect(url)
1803        else:
1804            auth=self._target.getSpeakerById(self._authorId)
1805            p = contributions.WPModSpeaker(self, self._target)
1806            wf = self.getWebFactory()
1807            if wf != None:
1808                p = wf.getModSpeaker(self, self._target)
1809            return p.display(author=auth)
1810
1811
1812class RHSubmittersRem(RHContribModifBaseSpecialSesCoordRights):
1813    _uh=urlHandlers.UHContribModSubmittersRem
1814
1815    def _checkParams(self, params):
1816        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1817        self._submitters=[]
1818        self._pendings=[]
1819        ah=user.PrincipalHolder()
1820        for id in self._normaliseListParam(params.get("selUsers", [])):
1821            av=ah.getById(id)
1822            if av is None:
1823                self._pendings.append(id)
1824            else:
1825                self._submitters.append(av)
1826
1827    def _process(self):
1828        for sub in self._submitters:
1829            self._target.revokeSubmission(sub)
1830        for email in self._pendings:
1831            self._target.revokeSubmissionEmail(email)
1832        self._redirect(urlHandlers.UHContribModifAC.getURL(self._target))
1833
1834
1835class RHSubmittersSel(RHContribModifBaseSpecialSesCoordRights):
1836    _uh=urlHandlers.UHContribModSubmittersSel
1837
1838    def _process(self):
1839        p=contributions.WPModSubmittersSel(self, self._target)
1840        return p.display(**self._getRequestParams())
1841
1842
1843class RHSubmittersAdd(RHContribModifBaseSpecialSesCoordRights):
1844    _uh=urlHandlers.UHContribModSubmittersAdd
1845
1846    def _checkParams(self, params):
1847        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1848        self._submitterRole=self._normaliseListParam(params.get("submitterRole", []))
1849
1850    def _process(self):
1851        params=self._getRequestParams()
1852        if "selectedPrincipals" in params and not "cancel" in params:
1853            ah=user.PrincipalHolder()
1854            for id in self._normaliseListParam(params["selectedPrincipals"]):
1855                av=ah.getById(id)
1856                self._target.grantSubmission(av)
1857                if self._submitterRole!=[] and not isinstance(av, user.Group):
1858                    cp=conference.ContributionParticipation()
1859                    cp.setDataFromAvatar(av)
1860                    if "primaryAuthor" in self._submitterRole:
1861                        self._target.addPrimaryAuthor(cp)
1862                    elif "coAuthor" in self._submitterRole:
1863                        self._target.addCoAuthor(cp)
1864                    if "speaker" in self._submitterRole:
1865                        if self._submitterRole in ["primaryAuthor", "coAuthor"]:
1866                            self._target.addSpeaker(cp)
1867                        else:
1868                            self._target.newSpeaker(cp)
1869        self._redirect(urlHandlers.UHContribModifAC.getURL(self._target))
1870
1871class RHMaterials(RHContribModifBaseSpecialSesCoordAndReviewingStaffRights):
1872    _uh = urlHandlers.UHContribModifMaterials
1873
1874    def _checkProtection(self):
1875        """ This disables people that are not conference managers or track coordinators to
1876            delete files from a contribution.
1877        """
1878        RHContribModifBaseSpecialSesCoordAndReviewingStaffRights._checkProtection(self)
1879        for key in self._paramsForCheckProtection.keys():
1880            if key.find("delete")!=-1:
1881                RHContribModifBaseSpecialSesCoordRights._checkProtection(self)
1882
1883    def _checkParams(self, params):
1884        RHContribModifBaseSpecialSesCoordAndReviewingStaffRights._checkParams(self, params)
1885        #if not hasattr(self, "_rhSubmitMaterial"):
1886        #    self._rhSubmitMaterial=RHSubmitMaterialBase(self._target, self)
1887        #self._rhSubmitMaterial._checkParams(params)
1888        params["days"] = params.get("day", "all")
1889        if params.get("day", None) is not None :
1890            del params["day"]
1891        # note from DavidMC: i wrote this long parameter name in order
1892        # not to overwrite a possibly existing _params in a base class
1893        # we need to store the params so that _checkProtection can know
1894        # if the action is to upload a file, delete etc.
1895        self._paramsForCheckProtection = params
1896
1897    def _process(self):
1898        if self._target.getOwner().isClosed():
1899            p = WPConferenceModificationClosed( self, self._target )
1900            return p.display()
1901
1902        p = contributions.WPContributionModifMaterials( self, self._target )
1903        return p.display(**self._getRequestParams())
1904
1905
1906
1907class RHContributionReportNumberEdit(RHContribModifBase):
1908
1909    def _checkParams(self, params):
1910        RHContribModifBase._checkParams(self, params)
1911        self._reportNumberSystem=params.get("reportNumberSystem","")
1912
1913    def _process(self):
1914        if self._reportNumberSystem!="":
1915            p=contributions.WPContributionReportNumberEdit(self,self._target, self._reportNumberSystem)
1916            return p.display()
1917        else:
1918            self._redirect(urlHandlers.UHContributionModification.getURL( self._target ))
1919
1920class RHContributionReportNumberPerformEdit(RHContribModifBase):
1921
1922    def _checkParams(self, params):
1923        RHContribModifBase._checkParams(self, params)
1924        self._reportNumberSystem=params.get("reportNumberSystem","")
1925        self._reportNumber=params.get("reportNumber","")
1926
1927    def _process(self):
1928        if self._reportNumberSystem!="" and self._reportNumber!="":
1929            self._target.getReportNumberHolder().addReportNumber(self._reportNumberSystem, self._reportNumber)
1930        self._redirect("%s#reportNumber"%urlHandlers.UHContributionModification.getURL( self._target ))
1931
1932
1933class RHContributionReportNumberRemove(RHContribModifBase):
1934
1935    def _checkParams(self, params):
1936        RHContribModifBase._checkParams(self, params)
1937        self._reportNumberIdsToBeDeleted=self._normaliseListParam( params.get("deleteReportNumber",[]))
1938
1939    def _process(self):
1940        nbDeleted = 0
1941        for id in self._reportNumberIdsToBeDeleted:
1942            self._target.getReportNumberHolder().removeReportNumberById(int(id)-nbDeleted)
1943            nbDeleted += 1
1944        self._redirect("%s#reportNumber"%urlHandlers.UHContributionModification.getURL( self._target ))
1945
1946
1947
Note: See TracBrowser for help on using the repository browser.