source: indico/indico/MaKaC/webinterface/rh/contribMod.py @ a89f94

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

[IMP] Access Protection Frame Improvement

  • fixes #429
  • The Access Control frame used to set the protection of a category/event/session/contribution has been modified in order to be more understandable and more intuitive.
  • In addition:

-> replaced the synchronous adding of users to the list of

allowed users by the corresponding Widget. Ajax methods for
getting, adding to and removing from this list were added
for each type of objects.

-> refactoring to a common .tpl and creation of a special

template for the 'Home' category
  • Property mode set to 100644
File size: 76.9 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
139
140class RHContributionModification(RHContribModifBaseSpecialSesCoordAndReviewingStaffRights):
141    _uh = urlHandlers.UHContributionModification
142
143    def _checkParams(self, params):
144        RHContribModifBase._checkParams(self, params)
145        params["days"] = params.get("day", "all")
146        if params.get("day", None) is not None :
147            del params["day"]
148
149    def _process(self):
150        params = self._getRequestParams()
151        if self._target.getOwner().isClosed():
152            p = contributions.WPContributionModificationClosed(self, self._target)
153        else:
154            wf = self.getWebFactory()
155            if wf != None:
156                p = wf.getContributionModification(self, self._target)
157            else:
158                p = contributions.WPContributionModification(self, self._target)
159        return p.display(**params)
160
161class RHWithdraw(RHContribModifBaseSpecialSesCoordRights):
162    _uh=urlHandlers.UHContribModWithdraw
163
164    def _checkParams(self, params):
165        RHContribModifBase._checkParams(self, params)
166        self._action=""
167        self._comment=""
168        if params.has_key("REACTIVATE"):
169            self._action="REACTIVATE"
170        elif params.has_key("OK"):
171            self._action="WITHDRAW"
172            self._comment=params.get("comment", "")
173        elif params.has_key("CANCEL"):
174            self._action="CANCEL"
175
176    def _process(self):
177        url=urlHandlers.UHContributionModification.getURL(self._target)
178        if self._action=="REACTIVATE":
179            self._target.withdraw(self._getUser(), self._comment)
180            self._redirect(url)
181            return
182        elif self._action=="WITHDRAW":
183            self._target.withdraw(self._getUser(), self._comment)
184            self._redirect(url)
185            return
186        elif self._action=="CANCEL":
187            self._redirect(url)
188            return
189        p=contributions.WPModWithdraw(self, self._target)
190        return p.display()
191
192
193class RHContributionAC(RHContribModifBaseSpecialSesCoordAndReviewingStaffRights):
194    _uh = urlHandlers.UHContribModifAC
195
196    def _checkParams(self, params):
197        RHContribModifBase._checkParams(self, params)
198        params["days"] = params.get("day", "all")
199        if params.get("day", None) is not None :
200            del params["day"]
201
202    def _process(self):
203        params = self._getRequestParams()
204        if self._target.getOwner().isClosed():
205            p = contributions.WPContributionModificationClosed(self, self._target)
206        else:
207            p = contributions.WPContribModifAC(self, self._target)
208            wf = self.getWebFactory()
209            if wf != None:
210                p = wf.getContribModifAC(self, self._target)
211        return p.display(**params)
212
213
214class RHContributionSC(RHContribModifBaseSpecialSesCoordAndReviewingStaffRights):
215    _uh = urlHandlers.UHContribModifSubCont
216
217    def _checkParams(self, params):
218        RHContribModifBase._checkParams(self, params)
219        params["days"] = params.get("day", "all")
220        if params.get("day", None) is not None :
221            del params["day"]
222
223    def _process(self):
224        params = self._getRequestParams()
225        p = contributions.WPContribModifSC(self, self._target)
226        wf = self.getWebFactory()
227        if wf != None:
228            p = wf.getContribModifSC(self, self._target)
229        return p.display(**params)
230
231class RHSubContribActions(RHContribModifBaseSpecialSesCoordRights):
232    _uh = urlHandlers.UHSubContribActions
233
234    def _checkParams(self, params):
235        RHContribModifBase._checkParams(self, params)
236        self._confirm = params.has_key("confirm")
237        self._scIds = self._normaliseListParam(params.get("selSubContribs", []))
238        self._action=None
239        if "cancel" in params:
240            return
241        self._action=[]
242        for id in self._scIds:
243            sc = self._target.getSubContributionById(id)
244            self._action.append(_ActionSubContribDelete(self, self._target, sc))
245        if params.has_key("oldpos") and params["oldpos"]!='':
246            self._action = _ActionSubContribMove(self, params['newpos'+params['oldpos']], params['oldpos'])
247
248    def _process(self):
249        if self._action is not None:
250            if isinstance(self._action, list):
251                for act in self._action:
252                    act.perform()
253            else:
254                self._action.perform()
255        self._redirect(urlHandlers.UHContribModifSubCont.getURL(self._target))
256
257class _ActionSubContribDelete:
258
259    def __init__(self, rh, target, sc):
260        self._rh = rh
261        self._target = target
262        self._sc = sc
263
264    def perform(self):
265        self._target.removeSubContribution(self._sc)
266
267class _ActionSubContribMove:
268
269    def __init__(self, rh, newpos, oldpos):
270        self._rh = rh
271        self._newpos = int(newpos)
272        self._oldpos = int(oldpos)
273
274    def perform(self):
275        scList = self._rh._target.getSubContributionList()
276        order = 0
277        movedsubcontrib = scList[self._oldpos]
278        del scList[self._oldpos]
279        scList.insert(self._newpos, movedsubcontrib)
280        self._rh._target.notifyModification()
281
282        #for sc in scList:
283        #    sc.setOrder(scList.index(sc))
284
285#-------------------------------------------------------------------------------------
286
287class RHContributionAddSC(RHContribModifBaseSpecialSesCoordRights):
288    _uh = urlHandlers.UHContribAddSubCont
289
290    def _process(self):
291        p = contributions.WPContribAddSC(self, self._target)
292        params = self._getRequestParams()
293        if params.get("recalled", None) is None :
294            self._removePreservedParams()
295            self._removeDefinedList("presenter")
296        params.update(self._getPreservedParams())
297        wf = self.getWebFactory()
298        if wf != None:
299            p = wf.getContribAddSC(self, self._target)
300
301        params["presenterDefined"] = self._getDefinedDisplayList("presenter")
302        params["presenterOptions"] = self._getPersonOptions("presenter")
303
304        params["days"] = params.get("day", "all")
305        if params.get("day", None) is not None :
306            del params["day"]
307
308        return p.display(**params)
309
310    def _getDefinedDisplayList(self, typeName):
311        return self._websession.getVar("%sList"%typeName)
312
313    def _getPreservedParams(self):
314        params = self._websession.getVar("preservedParams")
315        if params is None :
316            return {}
317        return params
318
319    def _removePreservedParams(self):
320        self._websession.setVar("preservedParams", None)
321
322    def _removeDefinedList(self, typeName):
323        self._websession.setVar("%sList"%typeName, None)
324
325    def _personInDefinedList(self, typeName, person):
326        list = self._websession.getVar("%sList"%typeName)
327        if list is None :
328            return False
329        for p in list :
330            if person.getFullName()+" "+person.getEmail() == p[0].getFullName()+" "+p[0].getEmail() :
331                return True
332        return False
333
334    def _getPersonOptions(self, typeName):
335        html = []
336        names = []
337        text = {}
338        html.append("""<option value=""> </option>""")
339        for contribution in self._target.getConference().getContributionList() :
340            for speaker in contribution.getSpeakerList() :
341                name = speaker.getFullNameNoTitle()
342                if not name in names and not self._personInDefinedList(typeName, speaker):
343                    text[name] = """<option value="s%s-%s">%s</option>"""%(contribution.getId(),speaker.getId(),name)
344                    names.append(name)
345            for author in contribution.getAuthorList() :
346                name = author.getFullNameNoTitle()
347                if not name in names and not self._personInDefinedList(typeName, author):
348                    text[name] = """<option value="a%s-%s">%s</option>"""%(contribution.getId(),author.getId(),name)
349                    names.append(name)
350            for coauthor in contribution.getCoAuthorList() :
351                name = coauthor.getFullNameNoTitle()
352                if not name in names and not self._personInDefinedList(typeName, coauthor):
353                    text[name] = """<option value="c%s-%s">%s</option>"""%(contribution.getId(),coauthor.getId(),name)
354                    names.append(name)
355        names.sort()
356        for name in names:
357            html.append(text[name])
358        return "".join(html)
359
360
361#-------------------------------------------------------------------------------------
362
363class RHContributionCreateSC(RHContribModifBaseSpecialSesCoordRights):
364    _uh = urlHandlers.UHContribCreateSubCont
365
366    def _process(self):
367
368        params = self._getRequestParams()
369        #params.update(self._getPreservedParams())
370        sc = self._target
371        """self._target - contribution owning new subcontribution"""
372
373        if ("ok" in params):
374            sc = self._target.newSubContribution()
375            sc.setTitle( params.get("title", "") )
376            sc.setDescription( params.get("description", "") )
377            sc.setKeywords( params.get("keywords", "") )
378            sc.setDuration( params.get("durationHours", ""), \
379                             params.get("durationMinutes", "") )
380            sc.setSpeakerText( params.get("speakers", "") )
381            sc.setParent(self._target)
382            for presenter in self._getDefinedList("presenter") :
383                sc.newSpeaker(presenter[0])
384
385            logInfo = sc.getLogInfo()
386            logInfo["subject"] = "Create new subcontribution: %s"%sc.getTitle()
387            self._target.getConference().getLogHandler().logAction(logInfo, "Timetable/SubContribution", self._getUser())
388
389            self._removePreservedParams()
390            self._removeDefinedList("presenter")
391            self._redirect(urlHandlers.UHContribModifSubCont.getURL(sc))
392        elif params.get("performedAction", "") == "New presenter" :
393            self._preserveParams(params)
394            self._redirect(urlHandlers.UHContribCreateSubContPresenterNew.getURL(self._target))
395        elif params.get("performedAction","") == "Search presenter" :
396            self._preserveParams(params)
397            self._redirect(urlHandlers.UHContribCreateSubContPresenterSearch.getURL(self._target))
398        elif params.get("performedAction", "") == "Add as presenter" :
399            self._preserveParams(params)
400            url = urlHandlers.UHContribCreateSubContPersonAdd.getURL(self._target)
401            url.addParam("typeName", "presenter")
402            url.addParam("orgin", "added")
403            self._redirect(url)
404        elif params.get("performedAction", "") == "Remove presenters" :
405            self._preserveParams(params)
406            self._removePersons(params, "presenter")
407            url = urlHandlers.UHContribAddSubCont.getURL(self._target)
408            url.addParam("recalled", "true")
409            self._redirect(url)
410        else:
411            self._removePreservedParams()
412            self._removeDefinedList("presenter")
413            self._redirect(urlHandlers.UHContribModifSubCont.getURL(sc))
414
415    def _getPreservedParams(self):
416        params = self._websession.getVar("preservedParams")
417        if params is None :
418            return {}
419        return params
420
421    def _preserveParams(self, params):
422        self._websession.setVar("preservedParams", params)
423
424    def _removePreservedParams(self):
425        self._websession.setVar("preservedParams", None)
426
427    def _getDefinedList(self, typeName):
428        definedList = self._websession.getVar("%sList"%typeName)
429        if definedList is None :
430            return []
431        return definedList
432
433    def _setDefinedList(self, definedList, typeName):
434        self._websession.setVar("%sList"%typeName, definedList)
435
436    def _removeDefinedList(self, typeName):
437        self._websession.setVar("%sList"%typeName, None)
438
439    def _removePersons(self, params, typeName):
440        persons = self._normaliseListParam(params.get("%ss"%typeName, []))
441        definedList = self._getDefinedList(typeName)
442        personsToRemove = []
443        for p in persons :
444            if int(p) < len(definedList) or int(p) >= 0 :
445                personsToRemove.append(definedList[int(p)])
446        for person in personsToRemove :
447            definedList.remove(person)
448        self._setDefinedList(definedList, typeName)
449
450#-------------------------------------------------------------------------------------
451
452class RHNewSubcontributionPresenterSearch(RHContribModifBaseSpecialSesCoordRights):
453    _uh = urlHandlers.UHContribCreateSubContPresenterSearch
454
455    def _checkParams(self, params):
456        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
457
458    def _process(self):
459        params = self._getRequestParams()
460
461        params["newButtonAction"] = str(urlHandlers.UHContribCreateSubContPresenterNew.getURL())
462        addURL = urlHandlers.UHContribCreateSubContPersonAdd.getURL()
463        addURL.addParam("orgin", "selected")
464        addURL.addParam("typeName", "presenter")
465        params["addURL"] = addURL
466        p = contributions.WSubContributionCreationPresenterSelect(self, self._target)
467        return p.display(**params)
468
469#-------------------------------------------------------------------------------------
470
471class RHNewSubcontributionPresenterNew(RHContribModifBaseSpecialSesCoordRights):
472    _uh = urlHandlers.UHContribCreateSubContPresenterNew
473
474    def _checkParams(self, params):
475        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
476
477    def _process(self):
478        p = contributions.WSubContributionCreationPresenterNew(self, self._target)
479        return p.display()
480
481#-------------------------------------------------------------------------------------
482
483class RHNewSubcontributionPersonAdd(RHContribModifBaseSpecialSesCoordRights):
484    _uh = urlHandlers.UHContribCreateSubContPersonAdd
485
486    def _checkParams(self, params):
487        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
488        self._typeName = params.get("typeName", None)
489        if self._typeName  is None :
490            raise MaKaCError( _("Type name of the person to add is not set."))
491
492    def _process(self):
493        params = self._getRequestParams()
494        self._errorList = []
495
496        definedList = self._getDefinedList(self._typeName)
497        if definedList is None :
498            definedList = []
499
500        if params.get("orgin", "") == "new" :
501            if params.get("ok", None) is None :
502                url = urlHandlers.UHContribAddSubCont.getURL(self._target)
503                url.addParam("recalled", "true")
504                self._redirect(url)
505                return
506            else :
507                person = SubContribParticipation()
508                person.setFirstName(params["name"])
509                person.setFamilyName(params["surName"])
510                person.setEmail(params["email"])
511                person.setAffiliation(params["affiliation"])
512                person.setAddress(params["address"])
513                person.setPhone(params["phone"])
514                person.setTitle(params["title"])
515                person.setFax(params["fax"])
516                if not self._alreadyDefined(person, definedList) :
517                    definedList.append([person, params.has_key("submissionControl")])
518                else :
519                    self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
520
521        elif params.get("orgin", "") == "selected":
522            selectedList = self._normaliseListParam(self._getRequestParams().get("selectedPrincipals", []))
523
524            for s in selectedList :
525                if s[0:8] == "*author*" :
526                    auths = self._target.getConference().getAuthorIndex()
527                    selected = auths.getById(s[9:])[0]
528                else :
529                    ph = user.PrincipalHolder()
530                    selected = ph.getById(s)
531                if isinstance(selected, user.Avatar) :
532                    person = SubContribParticipation()
533                    person.setDataFromAvatar(selected)
534                    if not self._alreadyDefined(person, definedList) :
535                        definedList.append([person, params.has_key("submissionControl")])
536                    else :
537                        self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
538
539                elif isinstance(selected, user.Group) :
540                    for member in selected.getMemberList() :
541                        person = SubContribParticipation()
542                        person.setDataFromAvatar(member)
543                        if not self._alreadyDefined(person, definedList) :
544                            definedList.append([person, params.has_key("submissionControl")])
545                        else :
546                            self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
547                else :
548                    person = SubContribParticipation()
549                    person.setTitle(selected.getTitle())
550                    person.setFirstName(selected.getFirstName())
551                    person.setFamilyName(selected.getFamilyName())
552                    person.setEmail(selected.getEmail())
553                    person.setAddress(selected.getAddress())
554                    person.setAffiliation(selected.getAffiliation())
555                    person.setPhone(selected.getPhone())
556                    person.setFax(selected.getFax())
557                    if not self._alreadyDefined(person, definedList) :
558                        definedList.append([person, params.has_key("submissionControl")])
559                    else :
560                        self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
561
562        elif params.get("orgin", "") == "added" :
563            preservedParams = self._getPreservedParams()
564            chosen = preservedParams.get("%sChosen"%self._typeName, None)
565            if chosen is None or chosen == "" :
566                url = urlHandlers.UHContribAddSubCont.getURL(self._target)
567                url.addParam("recalled", "true")
568                self._redirect(url)
569                return
570            index = chosen.find("-")
571            objectId = chosen[1:index]
572            chosenId = chosen[index+1:len(chosen)]
573            if chosen[0:1] == "d" :
574                object = self._target.getConference().getSessionById(objectId)
575            else :
576                object = self._target.getConference().getContributionById(objectId)
577            chosenPerson = None
578            if chosen[0:1] == "s" :
579                chosenPerson = object.getSpeakerById(chosenId)
580            elif chosen[0:1] == "a" :
581                chosenPerson = object.getAuthorById(chosenId)
582            elif chosen[0:1] == "c" :
583                chosenPerson = object.getCoAuthorById(chosenId)
584            elif chosen[0:1] == "d" :
585                chosenPerson = object.getConvenerById(chosenId)
586            elif index ==  -1 : #person data doesn't contain proper id
587                if self._getUser() and chosenId in self._getUser().getPersonalInfo().getBasket().getUsers() :   #checking if such person is listed on favourites
588                    chosenPerson = self._getUser().getPersonalInfo().getBasket().getUsers()[chosenId]
589            if chosenPerson is None :
590                self._redirect(urlHandlers.UHConfModScheduleNewContrib.getURL(self._target))
591                return
592            person = SubContribParticipation()
593            person.setTitle(chosenPerson.getTitle())
594            person.setFirstName(chosenPerson.getFirstName())
595            person.setFamilyName(chosenPerson.getFamilyName())
596            person.setEmail(chosenPerson.getEmail())
597            person.setAddress(chosenPerson.getAddress())
598            person.setAffiliation(chosenPerson.getAffiliation())
599            person.setPhone(chosenPerson.getPhone())
600            person.setFax(chosenPerson.getFax())
601            if not self._alreadyDefined(person, definedList) :
602                definedList.append([person, params.has_key("submissionControl")])
603            else :
604                self._errorList.append("%s has been already defined as %s of this session"%(person.getFullName(), self._typeName))
605        else :
606            self._redirect(urlHandlers.UHConfModifSchedule.getURL(self._target))
607            return
608        preservedParams = self._getPreservedParams()
609        preservedParams["errorMsg"] = self._errorList
610        self._preserveParams(preservedParams)
611        self._websession.setVar("%sList"%self._typeName, definedList)
612
613        url = urlHandlers.UHContribAddSubCont.getURL(self._target)
614        url.addParam("recalled", "true")
615        self._redirect(url)
616
617
618    def _getDefinedList(self, typeName):
619        definedList = self._websession.getVar("%sList"%typeName)
620        if definedList is None :
621            return []
622        return definedList
623
624    def _alreadyDefined(self, person, definedList):
625        if person is None :
626            return True
627        if definedList is None :
628            return False
629        fullName = person.getFullName()
630        for p in definedList :
631            if p[0].getFullName() == fullName :
632                return True
633        return False
634
635    def _getPreservedParams(self):
636        params = self._websession.getVar("preservedParams")
637        if params is None :
638            return {}
639        return params
640
641    def _preserveParams(self, params):
642        self._websession.setVar("preservedParams", params)
643
644    def _removePreservedParams(self):
645        self._websession.setVar("preservedParams", None)
646
647#-------------------------------------------------------------------------------------
648
649
650#class RHContributionDeleteSC( RHContribModifBase ):
651#    _uh = urlHandlers.UHContriDeleteSubCont
652#
653#    def _checkParams( self, params ):
654#        RHContribModifBase._checkParams( self, params )
655#        self._confirm = params.has_key( "confirm" )
656#        self._cancel = params.has_key( "cancel" )
657#        self._scIds = self._normaliseListParam( params.get("selSubContribs", []) )
658
659#    def _process( self ):
660#        for id in self._scIds:
661#            sc = self._target.getSubContributionById( id )
662#            self._target.removeSubContribution( sc )
663#        self._redirect( urlHandlers.UHContribModifSubCont.getURL( self._target ) )
664
665
666class RHContributionUpSC(RHContribModifBaseSpecialSesCoordRights):
667    _uh = urlHandlers.UHContribUpSubCont
668
669    def _checkParams(self, params):
670        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
671        self._scId = params.get("subContId", "")
672
673    def _process(self):
674        sc = self._target.getSubContributionById(self._scId)
675        self._target.upSubContribution(sc)
676        self._redirect(urlHandlers.UHContribModifSubCont.getURL(self._target))
677
678
679class RHContributionDownSC(RHContribModifBaseSpecialSesCoordRights):
680    _uh = urlHandlers.UHContribDownSubCont
681
682    def _checkParams(self, params):
683        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
684        self._scId = params.get("subContId", "")
685
686    def _process(self):
687        sc = self._target.getSubContributionById(self._scId)
688        self._target.downSubContribution(sc)
689        self._redirect(urlHandlers.UHContribModifSubCont.getURL(self._target))
690
691
692class RHContributionTools(RHContribModifBaseSpecialSesCoordAndReviewingStaffRights):
693    _uh = urlHandlers.UHContribModifTools
694
695    def _process(self):
696        if self._target.getOwner().isClosed():
697            p = contributions.WPContributionModificationClosed(self, self._target)
698        else:
699            p = contributions.WPContributionModifTools(self, self._target)
700            wf = self.getWebFactory()
701            if wf != None:
702                p = wf.getContributionModifTools(self, self._target)
703        return p.display()
704
705
706class RHContributionData( RoomBookingDBMixin, RHContribModifBaseSpecialSesCoordRights ):
707    _uh = urlHandlers.UHContributionDataModif
708
709    def _checkParams( self, params ):
710        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
711
712        self._evt = self._target
713
714    def _process(self):
715        if self._target.getOwner().isClosed():
716            p = contributions.WPContributionModificationClosed(self, self._target)
717        else:
718            p = contributions.WPEditData(self, self._target)
719            wf = self.getWebFactory()
720            if wf != None:
721                p = wf.getContributionEditData(self, self._target)
722        return p.display(**self._getRequestParams())
723
724
725class RHContributionModifData(RHContribModifBaseSpecialSesCoordRights):
726    _uh = urlHandlers.UHContributionDataModification
727
728    def _checkParams(self, params):
729        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
730        self._type=None
731        self._check = int(params.get("check", 1))
732        if params.has_key("type") and params["type"].strip()!="":
733            self._type=self._target.getConference().getContribTypeById(params["type"])
734        self._cancel = params.has_key("cancel")
735
736    def _process(self):
737        if not self._cancel:
738            params = self._getRequestParams()
739
740            if params.has_key("dateTime"):
741                dateTime = parseDateTime(params["dateTime"])
742                params["sYear"] = dateTime.year
743                params["sMonth"] = dateTime.month
744                params["sDay"] = dateTime.day
745                params["sHour"] = dateTime.hour
746                params["sMinute"] = dateTime.minute
747            else:
748                params["sYear"] = ""
749                params["sMonth"] = ""
750                params["sDay"] = ""
751                params["sHour"] = ""
752                params["sMinute"] = ""
753
754            if params.has_key("duration"):
755                params["durMins"] = params["duration"];
756            else:
757                params["durMins"] = ""
758            self._target.setValues(params)
759            self._target.setType(self._type)
760        self._redirect(urlHandlers.UHContributionModification.getURL(self._target))
761
762
763class RHSearchPrimaryAuthor (RHContribModifBaseSpecialSesCoordRights):
764    def _process(self):
765        p=contributions.WPModSearchPrimAuthor(self, self._target)
766        return p.display(**self._getRequestParams())
767
768class RHSearchAddPrimaryAuthor (RHContribModifBaseSpecialSesCoordRights):
769
770    def _newPrimAuthor(self, a):
771        auth = conference.ContributionParticipation()
772        p = self._getRequestParams()
773        auth.setTitle(a.getTitle())
774        auth.setFirstName(a.getName())
775        auth.setFamilyName(a.getSurName())
776        auth.setAffiliation(a.getOrganisation())
777        auth.setEmail(a.getEmail())
778        auth.setAddress(a.getAddress())
779        auth.setPhone(a.getTelephone())
780        auth.setFax(a.getFax())
781        self._target.addPrimaryAuthor(auth)
782        return auth
783
784    def _newPrimAuthorFromAuthor(self, a):
785        auth = conference.ContributionParticipation()
786        p = self._getRequestParams()
787        auth.setTitle(a.getTitle())
788        auth.setFirstName(a.getName())
789        auth.setFamilyName(a.getSurName())
790        auth.setAffiliation(a.getAffiliation())
791        auth.setEmail(a.getEmail())
792        auth.setAddress(a.getAddress())
793        auth.setPhone(a.getPhone())
794        auth.setFax(a.getFax())
795        self._target.addPrimaryAuthor(auth)
796        return auth
797
798    def _process(self):
799        params=self._getRequestParams()
800        if "selectedPrincipals" in params and not "cancel" in params:
801            ah=user.AvatarHolder()
802            authIndex = self._target.getConference().getAuthorIndex()
803            for id in self._normaliseListParam(params["selectedPrincipals"]):
804                if id[:9] == "*author*:":
805                    id = id[9:]
806                    auth=self._newPrimAuthorFromAuthor(authIndex.getById(id)[0])
807                else:
808                    auth=self._newPrimAuthor(ah.getById(id))
809                if self._getRequestParams().has_key("submissionControl"):
810                    self._target.grantSubmission(auth)
811        self._redirect(urlHandlers.UHContributionModification.getURL(self._target))
812
813class RHSearchCoAuthor (RHContribModifBaseSpecialSesCoordRights):
814    def _process(self):
815        p=contributions.WPModSearchCoAuthor(self, self._target)
816        return p.display(**self._getRequestParams())
817
818class RHSearchAddCoAuthor (RHContribModifBaseSpecialSesCoordRights):
819
820    def _newCoAuthor(self, a):
821        auth = conference.ContributionParticipation()
822        p = self._getRequestParams()
823        auth.setTitle(a.getTitle())
824        auth.setFirstName(a.getName())
825        auth.setFamilyName(a.getSurName())
826        auth.setAffiliation(a.getOrganisation())
827        auth.setEmail(a.getEmail())
828        auth.setAddress(a.getAddress())
829        auth.setPhone(a.getTelephone())
830        auth.setFax(a.getFax())
831        self._target.addCoAuthor(auth)
832        return auth
833
834    def _newCoAuthorFromAuthor(self, a):
835        auth = conference.ContributionParticipation()
836        p = self._getRequestParams()
837        auth.setTitle(a.getTitle())
838        auth.setFirstName(a.getName())
839        auth.setFamilyName(a.getSurName())
840        auth.setAffiliation(a.getAffiliation())
841        auth.setEmail(a.getEmail())
842        auth.setAddress(a.getAddress())
843        auth.setPhone(a.getPhone())
844        auth.setFax(a.getFax())
845        self._target.addCoAuthor(auth)
846        return auth
847
848    def _process(self):
849        params=self._getRequestParams()
850        if "selectedPrincipals" in params and not "cancel" in params:
851            ah=user.AvatarHolder()
852            authIndex = self._target.getConference().getAuthorIndex()
853            for id in self._normaliseListParam(params["selectedPrincipals"]):
854                if id[:9] == "*author*:":
855                    id = id[9:]
856                    auth=self._newCoAuthorFromAuthor(authIndex.getById(id)[0])
857                else:
858                    auth=self._newCoAuthor(ah.getById(id))
859                if self._getRequestParams().has_key("submissionControl"):
860                    self._target.grantSubmission(auth)
861        self._redirect(urlHandlers.UHContributionModification.getURL(self._target))
862
863
864class RHSearchSpeakers (RHContribModifBaseSpecialSesCoordRights):
865    def _process(self):
866        p=contributions.WPModSearchSpeaker(self, self._target)
867        return p.display(**self._getRequestParams())
868
869class RHSearchAddSpeakers (RHContribModifBaseSpecialSesCoordRights):
870
871    def _newSpeaker(self, a):
872        auth = conference.ContributionParticipation()
873        p = self._getRequestParams()
874        auth.setTitle(a.getTitle())
875        auth.setFirstName(a.getName())
876        auth.setFamilyName(a.getSurName())
877        auth.setAffiliation(a.getOrganisation())
878        auth.setEmail(a.getEmail())
879        auth.setAddress(a.getAddress())
880        auth.setPhone(a.getTelephone())
881        auth.setFax(a.getFax())
882        self._target.newSpeaker(auth)
883        return auth
884
885    def _newSpeakerFromAuthor(self, a):
886        auth = conference.ContributionParticipation()
887        p = self._getRequestParams()
888        auth.setTitle(a.getTitle())
889        auth.setFirstName(a.getName())
890        auth.setFamilyName(a.getSurName())
891        auth.setAffiliation(a.getAffiliation())
892        auth.setEmail(a.getEmail())
893        auth.setAddress(a.getAddress())
894        auth.setPhone(a.getPhone())
895        auth.setFax(a.getFax())
896        self._target.newSpeaker(auth)
897        return auth
898
899    def _process(self):
900        params=self._getRequestParams()
901        if "selectedPrincipals" in params and not "cancel" in params:
902            ah=user.AvatarHolder()
903            authIndex = self._target.getConference().getAuthorIndex()
904            for id in self._normaliseListParam(params["selectedPrincipals"]):
905                if id[:9] == "*author*:":
906                    id = id[9:]
907                    auth=self._newSpeakerFromAuthor(authIndex.getById(id)[0])
908                else:
909                    auth=self._newSpeaker(ah.getById(id))
910                if self._getRequestParams().has_key("submissionControl"):
911                    self._target.grantSubmission(auth)
912        self._redirect(urlHandlers.UHContributionModification.getURL(self._target))
913
914class RHNewPrimaryAuthor(RHContribModifBaseSpecialSesCoordRights):
915
916    def _checkParams(self, params):
917        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
918        self._action, self._new="", False
919        if params.has_key("ok"):
920            self._action = "perform"
921        elif params.has_key("ok_and_new"):
922            self._action = "perform"
923            self._new=True
924        elif params.has_key("cancel"):
925            self._action = "cancel"
926
927    def _newPrimAuthor(self):
928        auth = conference.ContributionParticipation()
929        p = self._getRequestParams()
930        auth.setTitle(p.get("title", ""))
931        auth.setFirstName(p.get("name", ""))
932        auth.setFamilyName(p.get("surName", ""))
933        auth.setAffiliation(p.get("affiliation", ""))
934        auth.setEmail(p.get("email", ""))
935        auth.setAddress(p.get("address", ""))
936        auth.setPhone(p.get("phone", ""))
937        auth.setFax(p.get("fax", ""))
938        self._target.addPrimaryAuthor(auth)
939        return auth
940
941
942    def _process(self):
943        url=urlHandlers.UHContributionModification.getURL(self._target)
944        if self._action=="cancel":
945            self._redirect(url)
946            return
947        elif self._action == "perform":
948            auth=self._newPrimAuthor()
949            if self._getRequestParams().has_key("submissionControl"):
950                if self._getRequestParams().get("email", "").strip() == "":
951                    raise FormValuesError("If you want to add the author as submitter, please enter their email")
952                self._target.grantSubmission(auth)
953            if not self._new:
954                self._redirect(url)
955                return
956        p = contributions.WPModNewPrimAuthor(self, self._target)
957        return p.display()
958
959
960class RHPrimaryAuthorsActions:
961    """
962    class to select the action to do with the selected authors
963    """
964    def __init__(self, req):
965        self._req = req
966
967    def process(self, params):
968        if params.has_key("REMOVE"):
969            return RHRemPrimaryAuthors(self._req).process(params)
970        elif params.has_key("MOVE"):
971            return RHMovePrimaryToCoAuthors(self._req).process(params)
972        return "no action to do"
973
974
975class RHRemPrimaryAuthors(RHContribModifBaseSpecialSesCoordRights):
976    def _checkParams(self, params):
977        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
978        self._list = []
979        for id in self._normaliseListParam(params.get("selAuthor", [])):
980            self._list.append(self._target.getAuthorById(id))
981
982    def _process(self):
983        for auth in self._list:
984            self._target.removePrimaryAuthor(auth)
985        url=urlHandlers.UHContributionModification.getURL(self._target)
986        self._redirect(url)
987
988class RHMovePrimaryToCoAuthors(RHContribModifBaseSpecialSesCoordRights):
989    def _checkParams(self, params):
990        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
991        self._list = []
992        for id in self._normaliseListParam(params.get("selAuthor", [])):
993            self._list.append(self._target.getAuthorById(id))
994
995    def _process(self):
996        for auth in self._list:
997            self._target.removePrimaryAuthor(auth, 0, False)
998            self._target.addCoAuthor(auth)
999        url=urlHandlers.UHContributionModification.getURL(self._target)
1000        self._redirect(url)
1001
1002
1003class RHEditPrimaryAuthor(RHContribModifBaseSpecialSesCoordRights):
1004
1005    def _checkParams(self, params):
1006        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1007        self._authorId=params["authorId"]
1008        self._action=""
1009        if params.has_key("ok"):
1010            self._action = "perform"
1011        elif params.has_key("cancel"):
1012            self._action = "cancel"
1013
1014    def _setPrimAuthorData(self):
1015        auth=self._target.getAuthorById(self._authorId)
1016        p = self._getRequestParams()
1017        auth.setTitle(p.get("title", ""))
1018        auth.setFirstName(p.get("name", ""))
1019        auth.setFamilyName(p.get("surName", ""))
1020        auth.setAffiliation(p.get("affiliation", ""))
1021        auth.setAddress(p.get("address", ""))
1022        auth.setPhone(p.get("phone", ""))
1023        auth.setFax(p.get("fax", ""))
1024
1025        grantSubm=False
1026        if auth.getEmail().lower().strip() != p.get("email", "").lower().strip():
1027            #----If it's already in the pending queue in order to grant
1028            #    submission rights we must unindex and after the modification of the email,
1029            #    index again...
1030            if self._target.getConference().getPendingQueuesMgr().isPendingSubmitter(auth):
1031                self._target.getConference().getPendingQueuesMgr().removePendingSubmitter(auth)
1032                grantSubm=True
1033            #-----
1034
1035        auth.setEmail(p.get("email", ""))
1036
1037        if grantSubm:
1038            self._target.grantSubmission(auth)
1039
1040    def _process(self):
1041        if self._action != "":
1042            if self._action == "perform":
1043                self._setPrimAuthorData()
1044            url=urlHandlers.UHContributionModification.getURL(self._target)
1045            self._redirect(url)
1046        else:
1047            auth=self._target.getAuthorById(self._authorId)
1048            p = contributions.WPModPrimAuthor(self, self._target)
1049            return p.display(author=auth)
1050
1051
1052class RHNewCoAuthor(RHContribModifBaseSpecialSesCoordRights):
1053
1054    def _checkParams(self, params):
1055        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1056        self._action, self._new="", False
1057        if params.has_key("ok"):
1058            self._action = "perform"
1059        elif params.has_key("ok_and_new"):
1060            self._action = "perform"
1061            self._new=True
1062        elif params.has_key("cancel"):
1063            self._action = "cancel"
1064
1065    def _newCoAuthor(self):
1066        auth = conference.ContributionParticipation()
1067        p = self._getRequestParams()
1068        auth.setTitle(p.get("title", ""))
1069        auth.setFirstName(p.get("name", ""))
1070        auth.setFamilyName(p.get("surName", ""))
1071        auth.setAffiliation(p.get("affiliation", ""))
1072        auth.setEmail(p.get("email", ""))
1073        auth.setAddress(p.get("address", ""))
1074        auth.setPhone(p.get("phone", ""))
1075        auth.setFax(p.get("fax", ""))
1076        self._target.addCoAuthor(auth)
1077        return auth
1078
1079    def _process(self):
1080        url=urlHandlers.UHContributionModification.getURL(self._target)
1081        if self._action=="cancel":
1082            self._redirect(url)
1083            return
1084        elif self._action=="perform":
1085            auth=self._newCoAuthor()
1086            if self._getRequestParams().has_key("submissionControl"):
1087                if self._getRequestParams().get("email", "").strip() == "":
1088                    raise FormValuesError("If you want to add the author as submitter, please enter their email")
1089                self._target.grantSubmission(auth)
1090            if not self._new:
1091                self._redirect(url)
1092                return
1093        p=contributions.WPModNewCoAuthor(self, self._target)
1094        return p.display()
1095
1096
1097class RHCoAuthorsActions:
1098    """
1099    class to select the action to do with the selected authors
1100    """
1101    def __init__(self, req):
1102        self._req = req
1103
1104    def process(self, params):
1105        if params.has_key("REMOVE"):
1106            return RHRemCoAuthors(self._req).process(params)
1107        elif params.has_key("MOVE"):
1108            return RHMoveCoToPrimaryAuthors(self._req).process(params)
1109        return "no action to do"
1110
1111
1112class RHRemCoAuthors(RHContribModifBaseSpecialSesCoordRights):
1113
1114    def _checkParams(self, params):
1115        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1116        self._list = []
1117        for id in self._normaliseListParam(params.get("selAuthor", [])):
1118            self._list.append(self._target.getAuthorById(id))
1119
1120    def _process(self):
1121        for auth in self._list:
1122            self._target.removeCoAuthor(auth)
1123        url=urlHandlers.UHContributionModification.getURL(self._target)
1124        self._redirect(url)
1125
1126class RHMoveCoToPrimaryAuthors(RHContribModifBaseSpecialSesCoordRights):
1127    def _checkParams(self, params):
1128        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1129        self._list = []
1130        for id in self._normaliseListParam(params.get("selAuthor", [])):
1131            self._list.append(self._target.getAuthorById(id))
1132
1133    def _process(self):
1134        for auth in self._list:
1135            self._target.removeCoAuthor(auth, 0, False)
1136            self._target.addPrimaryAuthor(auth)
1137        url=urlHandlers.UHContributionModification.getURL(self._target)
1138        self._redirect(url)
1139
1140class RHEditCoAuthor(RHContribModifBaseSpecialSesCoordRights):
1141
1142    def _checkParams(self, params):
1143        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1144        self._authorId=params["authorId"]
1145        self._action=""
1146        if params.has_key("ok"):
1147            self._action = "perform"
1148        elif params.has_key("cancel"):
1149            self._action = "cancel"
1150
1151    def _setCoAuthorData(self):
1152        auth=self._target.getAuthorById(self._authorId)
1153        p = self._getRequestParams()
1154        auth.setTitle(p.get("title", ""))
1155        auth.setFirstName(p.get("name", ""))
1156        auth.setFamilyName(p.get("surName", ""))
1157        auth.setAffiliation(p.get("affiliation", ""))
1158        auth.setAddress(p.get("address", ""))
1159        auth.setPhone(p.get("phone", ""))
1160        auth.setFax(p.get("fax", ""))
1161
1162        grantSubm=False
1163        if auth.getEmail().lower().strip() != p.get("email", "").lower().strip():
1164            #----If it's already in the pending queue in order to grant
1165            #    submission rights we must unindex and after the modification of the email,
1166            #    index again...
1167            if self._target.getConference().getPendingQueuesMgr().isPendingSubmitter(auth):
1168                self._target.getConference().getPendingQueuesMgr().removePendingSubmitter(auth)
1169                grantSubm=True
1170            #-----
1171
1172        auth.setEmail(p.get("email", ""))
1173
1174        if grantSubm:
1175            self._target.grantSubmission(auth)
1176
1177    def _process(self):
1178        if self._action != "":
1179            if self._action == "perform":
1180                self._setCoAuthorData()
1181            url=urlHandlers.UHContributionModification.getURL(self._target)
1182            self._redirect(url)
1183        else:
1184            auth=self._target.getAuthorById(self._authorId)
1185            p = contributions.WPModCoAuthor(self, self._target)
1186            return p.display(author=auth)
1187
1188
1189class RHRemSpeakers(RHContribModifBaseSpecialSesCoordRights):
1190
1191    def _checkParams(self, params):
1192        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1193        self._list = []
1194        for id in self._normaliseListParam(params.get("selSpeaker", [])):
1195            self._list.append(self._target.getSpeakerById(id))
1196
1197    def _process(self):
1198        for auth in self._list:
1199            if auth is None:
1200                continue
1201            self._target.removeSpeaker(auth)
1202        url=urlHandlers.UHContributionModification.getURL(self._target)
1203        self._redirect(url)
1204
1205
1206class RHAddSpeakers(RHContribModifBaseSpecialSesCoordRights):
1207
1208    def _checkParams(self, params):
1209        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1210        self._list = []
1211        for id in self._normaliseListParam(params.get("selAuthor", [])):
1212            self._list.append(self._target.getAuthorById(id))
1213
1214    def _process(self):
1215        for auth in self._list:
1216            if auth is None:
1217                continue
1218            self._target.addSpeaker(auth)
1219        url=urlHandlers.UHContributionModification.getURL(self._target)
1220        self._redirect(url)
1221
1222
1223class RHSetTrack(RHContribModifBase):
1224
1225    def _checkParams(self, params):
1226        RHContribModifBase._checkParams(self, params)
1227        self._track=None
1228        if params.has_key("selTrack") and params["selTrack"].strip() != "":
1229            self._track = self._target.getConference().getTrackById(params["selTrack"])
1230
1231    def _process(self):
1232        self._target.setTrack(self._track)
1233        url=urlHandlers.UHContributionModification.getURL(self._target)
1234        self._redirect(url)
1235
1236
1237class RHSetSession(RHContribModifBase):
1238
1239    def _checkParams(self, params):
1240        RHContribModifBase._checkParams(self, params)
1241        self._session=None
1242        if params.has_key("selSession") and params["selSession"].strip() != "":
1243            self._session=self._target.getConference().getSessionById(params["selSession"])
1244
1245    def _process(self):
1246        self._target.setSession(self._session)
1247        url=urlHandlers.UHContributionModification.getURL(self._target)
1248        self._redirect(url)
1249
1250
1251#class RHContributionSelectSpeakers( RHContribModifBase ):
1252#    _uh = urlHandlers.UHContributionSelectSpeakers
1253#
1254#    def _process( self ):
1255#        p = contributions.WPcontribSelectChairs( self, self._target )
1256#        return p.display( **self._getRequestParams() )
1257#
1258#
1259#class RHContributionAddSpeakers( RHContribModifBase ):
1260#    _uh = urlHandlers.UHContributionAddSpeakers
1261#
1262#    def _checkParams( self, params ):
1263#        RHContribModifBase._checkParams( self, params )
1264#        selSpeakerId = self._normaliseListParam( params.get( "selectedPrincipals", [] ) )
1265#        ah = user.AvatarHolder()
1266#        self._speakers = []
1267#        for id in selSpeakerId:
1268#            self._speakers.append( ah.getById( id ) )
1269#
1270#    def _process( self ):
1271#        for av in self._speakers:
1272#            self._target.addSpeaker( av )
1273#        self._redirect( urlHandlers.UHContributionModification.getURL( self._target ) )
1274#
1275#
1276#class RHContributionRemoveSpeakers( RHContribModifBase ):
1277#    _uh = urlHandlers.UHContributionRemoveSpeakers
1278#
1279#    def _checkParams( self, params ):
1280#        RHContribModifBase._checkParams( self, params )
1281#        selSpeakerId = self._normaliseListParam( params.get( "selectedPrincipals", [] ) )
1282#        ah = user.AvatarHolder()
1283#        self._speakers = []
1284#        for id in selSpeakerId:
1285#            self._speakers.append( ah.getById( id ) )
1286#
1287#    def _process( self ):
1288#        for av in self._speakers:
1289#            self._target.removeSpeaker( av )
1290#        self._redirect( urlHandlers.UHContributionModification.getURL( self._target ) )
1291
1292
1293class RHContributionAddMaterial(RHContribModifBaseSpecialSesCoordRights):
1294    _uh = urlHandlers.UHContributionAddMaterial
1295
1296    def _checkParams(self, params):
1297        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1298        typeMat = params.get("typeMaterial", "notype")
1299        if typeMat=="notype" or typeMat.strip()=="":
1300            raise FormValuesError("Please choose a material type")
1301        self._mf = materialFactories.ContribMFRegistry().getById(typeMat)
1302
1303    def _process(self):
1304        if self._mf:
1305            if not self._mf.needsCreationPage():
1306                m = RHContributionPerformAddMaterial.create(self._target, self._mf, self._getRequestParams())
1307                self._redirect(urlHandlers.UHMaterialModification.getURL(m))
1308                return
1309        p = contributions.WPContribAddMaterial(self, self._target, self._mf)
1310        wf = self.getWebFactory()
1311        if wf != None:
1312            p = wf.getContribAddMaterial(self, self._target, self._mf)
1313        return p.display()
1314
1315
1316class RHContributionPerformAddMaterial(RHContribModifBaseSpecialSesCoordRights):
1317    _uh = urlHandlers.UHContributionPerformAddMaterial
1318
1319    def _checkParams(self, params):
1320        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1321        typeMat = params.get("typeMaterial", "")
1322        self._mf = materialFactories.ContribMFRegistry.getById(typeMat)
1323
1324    @staticmethod
1325    def create(contrib, matFactory, matData):
1326        if matFactory:
1327            m = matFactory.create(contrib)
1328        else:
1329            m = conference.Material()
1330            contrib.addMaterial(m)
1331            m.setValues(matData)
1332        return m
1333
1334    def _process(self):
1335        m = self.create(self._target, self._mf, self._getRequestParams())
1336        self._redirect(urlHandlers.UHMaterialModification.getURL(m))
1337
1338
1339class RHContributionRemoveMaterials(RHContribModifBaseSpecialSesCoordRights):
1340    _uh = urlHandlers.UHContributionRemoveMaterials
1341
1342    def _checkParams(self, params):
1343        RHContribModifBaseSpecialSesCoordRights._checkParams(self, params)
1344        #typeMat = params.get( "typeMaterial", "" )
1345        #self._mf = materialFactories.ConfMFRegistry().getById( typeMat )
1346        self._materialIds = self._normaliseListParam(params.get("deleteMaterial", []))
1347        self._materialIds = self._normaliseListParam( params.get("materialId", []) )
1348        self._returnURL = params.get("returnURL","")
1349
1350    def _process(self):
1351        for id in self._materialIds:
1352            #Performing the deletion of special material types
1353            f = materialFactories.ContribMFRegistry().getById(id)
1354            if f:
1355                f.remove(self._target)
1356            else:
1357                #Performs the deletion of additional material types
1358                mat = self._target.getMaterialById( id )
1359                self._target.removeMaterial( mat )
1360        if self._returnURL != "":
1361            url = self._returnURL
1362        else:
1363            url = urlHandlers.UHContribModifMaterials.getURL( self._target )
1364        self._redirect( url )
1365
1366
1367class RHMaterialsAdd(RHContribModifBaseSpecialSesCoordRights):
1368    _uh = urlHandlers.UHContribModifAddMaterials
1369
1370    def _checkProtection(self):
1371        material, _ = self._rhSubmitMaterial._getMaterial(forceCreate = False)
1372        if self._target.canUserSubmit(self._aw.getUser()) \
1373            and (not material or material.getReviewingState() < 3):
1374            return
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.