source: indico/indico/MaKaC/services/implementation/contribution.py @ 3982db

hello-world-walkthroughipv6v0.98-seriesv0.98.2v0.98.3v0.99v1.0v1.1
Last change on this file since 3982db was 3982db, checked in by Jose Benito <jose.benito.gonzalez@…>, 13 months ago

[IMP] Improvement of contribution display

  • Refactor and redesign of the page.
  • New paper review workflow.
  • New popups to show more information.
  • Close #1022.
  • Property mode set to 100644
File size: 38.9 KB
Line 
1from MaKaC.services.implementation.base import ProtectedModificationService
2from MaKaC.services.implementation.base import ProtectedDisplayService
3from MaKaC.services.implementation.base import ParameterManager
4from MaKaC.services.implementation.roomBooking import GetBookingBase
5
6from MaKaC.services.interface.rpc.common import ServiceError, ServiceAccessError
7
8from MaKaC.common.PickleJar import DictPickler
9
10import MaKaC.conference as conference
11from MaKaC.services.implementation.base import TextModificationBase
12from MaKaC.services.implementation.base import HTMLModificationBase
13from MaKaC.services.implementation.base import DateTimeModificationBase
14from MaKaC.common.fossilize import fossilize
15from MaKaC.fossils.subcontribution import ISubContribParticipationFullFossil
16from MaKaC.user import PrincipalHolder, Avatar, Group, AvatarHolder
17import MaKaC.webinterface.pages.contributionReviewing as contributionReviewing
18import MaKaC.webinterface.wcomponents as wcomponents
19
20class ContributionBase(object):
21
22    def _checkParams( self ):
23        try:
24            self._target = self._conf = conference.ConferenceHolder().getById(self._params["conference"]);
25        except:
26            try:
27                self._target = self._conf = conference.ConferenceHolder().getById(self._params["confId"]);
28            except:
29                raise ServiceError("ERR-E4", "Invalid conference id.")
30
31        if self._conf == None:
32            raise Exception("Conference id not specified.")
33
34        try:
35            self._target = self._contribution = self._conf.getContributionById(self._params["contribution"])
36        except:
37            try:
38                self._target = self._contribution = self._conf.getContributionById(self._params["contribId"])
39            except:
40                raise ServiceError("ERR-C0", "Invalid contribution id.")
41
42        if self._target == None:
43            raise Exception("Contribution id not specified.")
44
45        # create a parameter manager that checks the consistency of passed parameters
46        self._pm = ParameterManager(self._params)
47
48class ContributionDisplayBase(ProtectedDisplayService, ContributionBase):
49
50    def _checkParams(self):
51        ContributionBase._checkParams(self)
52        ProtectedDisplayService._checkParams(self)
53
54class ContributionModifBase(ProtectedModificationService, ContributionBase):
55
56    def _checkParams(self):
57        ContributionBase._checkParams(self)
58        ProtectedModificationService._checkParams(self)
59
60    def _checkProtection(self):
61        if self._target.getSession() != None:
62            if self._target.getSession().canCoordinate(self.getAW(), "modifContribs"):
63                return
64        ProtectedModificationService._checkProtection(self)
65
66class ContributionTextModificationBase(TextModificationBase, ContributionBase):
67    pass
68
69class ContributionHTMLModificationBase(HTMLModificationBase, ContributionBase):
70    pass
71
72class ContributionDateTimeModificationBase (DateTimeModificationBase, ContributionBase):
73    pass
74
75class ContributionAddSubContribution(ContributionModifBase):
76    def _checkParams(self):
77        ContributionModifBase._checkParams(self)
78
79        # "presenters" and "keywords" are not required. they can be empty
80        self._presenters = self._pm.extract("presenters", pType=list, allowEmpty=True)
81        self._keywords = self._pm.extract("keywords", pType=list, allowEmpty=True)
82        self._description = self._pm.extract("description", pType=str, allowEmpty=True, defaultValue="")
83        self._reportNumbers = self._pm.extract("reportNumbers", pType=list, allowEmpty=True, defaultValue=[])
84        self._materials = self._pm.extract("materials", pType=dict, allowEmpty=True)
85
86        # these are required
87        self._duration = self._pm.extract("duration", pType=int)
88        self._title = self._pm.extract("title", pType=str)
89
90    def __addPresenters(self, subcontrib):
91
92        # add each presenter
93        for presenterValues in self._presenters:
94
95            # magically update a new ContributionParticipation with JSON data, using the DictPickler
96            presenter = conference.SubContribParticipation()
97            DictPickler.update(presenter, presenterValues)
98
99            subcontrib.newSpeaker(presenter)
100
101    def __addMaterials(self, subcontrib):
102        if self._materials:
103            for material in self._materials.keys():
104                newMaterial = conference.Material()
105                newMaterial.setTitle(material)
106                for resource in self._materials[material]:
107                    newLink = conference.Link()
108                    newLink.setURL(resource)
109                    newLink.setName(resource)
110                    newMaterial.addResource(newLink)
111                subcontrib.addMaterial(newMaterial)
112
113    def __addReportNumbers(self, subcontrib):
114        if self._reportNumbers:
115            for reportTuple in self._reportNumbers:
116                for recordNumber in reportTuple[1]:
117                    subcontrib.getReportNumberHolder().addReportNumber(reportTuple[0], recordNumber)
118
119    def _getAnswer(self):
120        # create the sub contribution
121        sc = self._target.newSubContribution()
122
123        sc.setTitle( self._title )
124        sc.setDescription( self._description )
125        # separate the keywords using newlines
126        sc.setKeywords('\n'.join(self._keywords))
127        sc.setDuration( self._duration / 60, \
128                         self._duration % 60 )
129
130        self.__addMaterials(sc)
131        self.__addReportNumbers(sc)
132        self.__addPresenters(sc)
133
134        # log the event
135        logInfo = sc.getLogInfo()
136        logInfo["subject"] = "Create new subcontribution: %s"%sc.getTitle()
137        self._target.getConference().getLogHandler().logAction(logInfo, "Timetable/SubContribution", self._getUser())
138
139class ContributionDeleteSubContribution(ContributionModifBase):
140
141    # contribution.deleteSubContribution
142
143    _asyndicoDoc = {
144        'summary':  'Deletes a subcontribution, given the conference, contribution and subcontribution IDs.',
145        'params': [{'name': 'conference', 'type': 'str'},
146                   {'name': 'contribution', 'type': 'str'},
147                   {'name': 'subcontribution', 'type': 'str'}],
148        'return': None
149        }
150
151    def _checkParams(self):
152        ContributionModifBase._checkParams(self)
153
154        subContId = self._pm.extract("subcontribution", pType=str, allowEmpty=False)
155
156        self._subContribution = self._contribution.getSubContributionById(subContId)
157
158    def _getAnswer(self):
159        self._subContribution.getOwner().removeSubContribution(self._subContribution)
160
161class ContributionGetBooking(ContributionDisplayBase, GetBookingBase):
162    pass
163
164class ContributionProtectionUserList(ContributionModifBase):
165
166    def _getAnswer(self):
167        #will use IAvatarFossil or IGroupFossil
168        return fossilize(self._contribution.getAllowedToAccessList())
169
170class ContributionProtectionAddUsers(ContributionModifBase):
171
172    def _checkParams(self):
173        ContributionModifBase._checkParams(self)
174
175        self._usersData = self._params['value']
176        self._user = self.getAW().getUser()
177
178    def _getAnswer(self):
179
180        for user in self._usersData :
181
182            userToAdd = PrincipalHolder().getById(user['id'])
183
184            if not userToAdd :
185                raise ServiceError("ERR-U0","User does not exist!")
186
187            self._contribution.grantAccess(userToAdd)
188
189class ContributionProtectionRemoveUser(ContributionModifBase):
190
191    def _checkParams(self):
192        ContributionModifBase._checkParams(self)
193
194        self._userData = self._params['value']
195
196        self._user = self.getAW().getUser()
197
198    def _getAnswer(self):
199
200        userToRemove = PrincipalHolder().getById(self._userData['id'])
201
202        if not userToRemove :
203            raise ServiceError("ERR-U0","User does not exist!")
204        elif isinstance(userToRemove, Avatar) or isinstance(userToRemove, Group) :
205            self._contribution.revokeAccess(userToRemove)
206
207
208class ContributionParticipantsBase(ContributionModifBase):
209
210    def _checkParams(self):
211        ContributionModifBase._checkParams(self)
212        self._pm = ParameterManager(self._params)
213        self._kindOfList = self._pm.extract("kindOfList", pType=str, allowEmpty=False)
214
215    def _isEmailAlreadyUsed(self, email):
216        participantList = []
217        if self._kindOfList in ("prAuthor", "coAuthor"):
218            participantList = self._contribution.getPrimaryAuthorList() + self._contribution.getCoAuthorList()
219        elif self._kindOfList == "speaker":
220            participantList = self._contribution.getSpeakerList()
221
222        for part in participantList:
223            if email == part.getEmail():
224                return True
225        return False
226
227    def _getParticipantsList(self, participantList):
228        result = []
229        for part in participantList:
230            partFossil = fossilize(part)
231            # var to control if we have to show the entry in the author menu to allow add submission rights
232            isSubmitter = False
233            av = AvatarHolder().match({"email": part.getEmail()}, forceWithoutExtAuth=True, exact=True)
234            if not av:
235                if part.getEmail() in self._contribution.getSubmitterEmailList():
236                    isSubmitter = True
237            elif (av[0] in self._contribution.getSubmitterList() or self._conf.getPendingQueuesMgr().isPendingSubmitter(part)):
238                isSubmitter = True
239            partFossil["showSubmitterCB"] = not isSubmitter
240            result.append(partFossil)
241        return result
242
243
244
245class ContributionParticipantsUserBase(ContributionParticipantsBase):
246
247    def _checkParams(self):
248        ContributionParticipantsBase._checkParams(self)
249        if self._kindOfList == "speaker":
250            self._participant = self._contribution.getSpeakerById(self._pm.extract("userId", pType=str, allowEmpty=False))
251        else:
252            self._participant = self._contribution.getAuthorById(self._pm.extract("userId", pType=str, allowEmpty=False))
253        if self._participant == None:
254            raise ServiceError("ERR-U0", _("User does not exist."))
255
256
257class ContributionAddExistingParticipant(ContributionParticipantsBase):
258
259    def _checkParams(self):
260        ContributionParticipantsBase._checkParams(self)
261        self._submissionRights = self._pm.extract("presenter-grant-submission", pType=bool, allowEmpty=False)
262        self._userList = self._pm.extract("userList", pType=list, allowEmpty=False)
263        # Check if there is already a user with the same email
264        for user in self._userList:
265            if self._isEmailAlreadyUsed(user["email"]):
266                if self._kindOfList == "speaker":
267                    raise ServiceAccessError(_("The email address %s (belonging to a user you are adding) is already used by another speaker in the current speaker list. Speaker(s) not added.") % user["email"])
268                else:
269                    raise ServiceAccessError(_("The email address %s (belonging to a user you are adding) is already used by another author in the list of primary authors or co-authors. Author(s) not added.") % user["email"])
270
271    def _newParticipant(self, a):
272        part = conference.ContributionParticipation()
273        part.setTitle(a.getTitle())
274        part.setFirstName(a.getName())
275        part.setFamilyName(a.getSurName())
276        part.setAffiliation(a.getOrganisation())
277        part.setEmail(a.getEmail())
278        part.setAddress(a.getAddress())
279        part.setPhone(a.getTelephone())
280        part.setFax(a.getFax())
281        if self._kindOfList == "prAuthor":
282            self._contribution.addPrimaryAuthor(part)
283        elif self._kindOfList == "coAuthor":
284            self._contribution.addCoAuthor(part)
285        elif self._kindOfList == "speaker":
286            self._contribution.newSpeaker(part)
287        return part
288
289    def _getAnswer(self):
290        for user in self._userList:
291            if user["_type"] == "Avatar": # new speaker
292                ah = AvatarHolder()
293                av = ah.getById(user["id"])
294                part = self._newParticipant(av)
295            elif user["_type"] == "ContributionParticipation": # adding existing author to speaker
296                part = self._contribution.getAuthorById(user["id"])
297                self._contribution.addSpeaker(part)
298            if self._submissionRights and part:
299                self._contribution.grantSubmission(part)
300
301        if self._kindOfList == "prAuthor":
302            return self._getParticipantsList(self._contribution.getPrimaryAuthorList())
303        elif self._kindOfList == "coAuthor":
304            return self._getParticipantsList(self._contribution.getCoAuthorList())
305        elif self._kindOfList == "speaker":
306            return self._getParticipantsList(self._contribution.getSpeakerList())
307        else:
308            raise ServiceError("ERR-UK0", _("Invalid kind of list of users."))
309
310
311class ContributionAddNewParticipant(ContributionParticipantsBase):
312
313    def _checkParams(self):
314        ContributionParticipantsBase._checkParams(self)
315        self._userData = self._pm.extract("userData", pType=dict, allowEmpty=False)
316        email = self._userData.get("email", "")
317        if email != "" and self._isEmailAlreadyUsed(email):
318            raise ServiceAccessError(_("The email address is already used by another %s. %s not added.") % (self._kindOfList, self._kindOfList))
319
320    def _newParticipant(self):
321        part = conference.ContributionParticipation()
322        part.setTitle(self._userData.get("title", ""))
323        part.setFirstName(self._userData.get("firstName", ""))
324        part.setFamilyName(self._userData.get("familyName", ""))
325        part.setAffiliation(self._userData.get("affiliation", ""))
326        part.setEmail(self._userData.get("email", ""))
327        part.setAddress(self._userData.get("address", ""))
328        part.setPhone(self._userData.get("phone", ""))
329        part.setFax(self._userData.get("fax", ""))
330        if self._kindOfList == "prAuthor":
331            self._contribution.addPrimaryAuthor(part)
332        elif self._kindOfList == "coAuthor":
333            self._contribution.addCoAuthor(part)
334        elif self._kindOfList == "speaker":
335            self._contribution.newSpeaker(part)
336        #If the participant needs to be given submission rights
337        if self._userData.get("submission", False):
338            if self._userData.get("email", "") == "":
339                raise ServiceAccessError(_("It is necessary to enter the email of the %s if you want to add him as submitter.") % self._kindOfList)
340            self._contribution.grantSubmission(part)
341
342    def _getAnswer(self):
343        self._newParticipant()
344        if self._kindOfList == "prAuthor":
345            return self._getParticipantsList(self._contribution.getPrimaryAuthorList())
346        elif self._kindOfList == "coAuthor":
347            return self._getParticipantsList(self._contribution.getCoAuthorList())
348        elif self._kindOfList == "speaker":
349            return self._getParticipantsList(self._contribution.getSpeakerList())
350        else:
351            raise ServiceError("ERR-UK0", _("Invalid kind of list of users."))
352
353
354class ContributionRemoveParticipant(ContributionParticipantsUserBase):
355
356    def _getAnswer(self):
357        if self._kindOfList == "prAuthor":
358            self._contribution.removePrimaryAuthor(self._participant, removeSpeaker=0)
359            #return [self._getParticipantsList(self._contribution.getPrimaryAuthorList()), self._getParticipantsList(self._contribution.getSpeakerList())]
360            return self._getParticipantsList(self._contribution.getPrimaryAuthorList())
361        elif self._kindOfList == "coAuthor":
362            self._contribution.removeCoAuthor(self._participant, removeSpeaker=0)
363            #return [self._getParticipantsList(self._contribution.getCoAuthorList()), self._getParticipantsList(self._contribution.getSpeakerList())]
364            return self._getParticipantsList(self._contribution.getCoAuthorList())
365        elif self._kindOfList == "speaker":
366            self._contribution.removeSpeaker(self._participant)
367            return self._getParticipantsList(self._contribution.getSpeakerList())
368        else:
369            raise ServiceError("ERR-UK0", _("Invalid kind of list of users."))
370
371
372class ContributionEditParticipantData(ContributionParticipantsBase):
373
374    def _checkParams(self):
375        ContributionParticipantsBase._checkParams(self)
376        self._userData = self._pm.extract("userData", pType=dict, allowEmpty=False)
377        self._userId = self._pm.extract("userId", pType=str, allowEmpty=False)
378        if (self._kindOfList == "speaker"):
379            self._participant = self._contribution.getSpeakerById(self._pm.extract("userId", pType=str, allowEmpty=False))
380        else:
381            self._participant = self._contribution.getAuthorById(self._pm.extract("userId", pType=str, allowEmpty=False))
382        if self._participant == None:
383            raise ServiceError("ERR-U0", _("User does not exist."))
384        if self._userData.get("email", "") != "" and self._isEmailAlreadyUsed():
385            raise ServiceAccessError(_("The email address is already used by another participant. Participant not modified."))
386        #self._eventType = self._pm.extract("eventType", pType=str, allowEmpty=False)
387
388    def _isEmailAlreadyUsed(self):
389        participantList = []
390        if self._kindOfList in ("prAuthor", "coAuthor"):
391            participantList = self._contribution.getPrimaryAuthorList() + self._contribution.getCoAuthorList()
392        elif self._kindOfList == "speaker":
393            participantList = self._contribution.getSpeakerList()
394        for auth in participantList:
395            # check if the email is already used by other different author
396            if self._userData.get("email", "") == auth.getEmail() and self._userId != str(auth.getId()):
397                return True
398        return False
399
400    def _editParticipant(self):
401        self._participant.setTitle(self._userData.get("title", ""))
402        self._participant.setFirstName(self._userData.get("firstName", ""))
403        self._participant.setFamilyName(self._userData.get("familyName", ""))
404        self._participant.setAffiliation(self._userData.get("affiliation", ""))
405        self._participant.setAddress(self._userData.get("address", ""))
406        self._participant.setPhone(self._userData.get("phone", ""))
407        self._participant.setFax(self._userData.get("fax", ""))
408
409        grantSubm = False
410        if self._participant.getEmail().lower().strip() != self._userData.get("email", "").lower().strip():
411            #----If it's already in the pending queue in order to grant
412            #    submission rights we must unindex and after the modification of the email,
413            #    index again...
414            if self._conf.getPendingQueuesMgr().isPendingSubmitter(self._participant):
415                self._conf.getPendingQueuesMgr().removePendingSubmitter(self._participant)
416                grantSubm = True
417            #-----
418        self._participant.setEmail(self._userData.get("email", ""))
419        #If the author needs to be given submission rights because the checkbox is selected
420        if self._userData.get("submission", False):
421            if self._userData.get("email", "") == "":
422                raise ServiceAccessError(_("It is necessary to enter the email of the user if you want to add him as submitter."))
423            grantSubm = True
424        if grantSubm:
425            self._contribution.grantSubmission(self._participant)
426
427    def _getAnswer(self):
428        self._editParticipant()
429        if self._kindOfList == "prAuthor":
430            return self._getParticipantsList(self._contribution.getPrimaryAuthorList())
431        elif self._kindOfList == "coAuthor":
432            return self._getParticipantsList(self._contribution.getCoAuthorList())
433        elif self._kindOfList == "speaker":
434            return self._getParticipantsList(self._contribution.getSpeakerList())
435        else:
436            raise ServiceError("ERR-UK0", _("Invalid kind of list of users."))
437
438
439class ContributionSendEmailData(ContributionParticipantsUserBase):
440
441    def _getAnswer(self):
442        return {"confTitle": self._conf.getTitle(),
443                "contribTitle": self._contribution.getTitle(),
444                "contribId": str(self._contribution.getId()),
445                "email": self._participant.getEmail()
446                }
447
448
449class ContributionChangeSubmissionRights(ContributionParticipantsUserBase):
450
451    def _checkParams(self):
452        ContributionParticipantsUserBase._checkParams(self)
453        if self._participant.getEmail() == "":
454            raise ServiceAccessError(_("It is not possible to grant submission rights to a participant without an email address. Please edit participant details and set an email address."))
455        self._action = self._pm.extract("action", pType=str, allowEmpty=False)
456        self._eventType = self._pm.extract("eventType", pType=str, allowEmpty=False)
457
458    def _getAnswer(self):
459        if self._action == "grant":
460            self._contribution.grantSubmission(self._participant)
461        elif self._action == "remove":
462            av = AvatarHolder().match({"email": self._participant.getEmail()}, exact=True, forceWithoutExtAuth=True)
463            if not av:
464                self._contribution.revokeSubmissionEmail(self._participant.getEmail())
465            else:
466                self._contribution.revokeSubmission(av[0])
467        if self._eventType == "conference":
468            return [self._getParticipantsList(self._contribution.getPrimaryAuthorList()),
469                    self._getParticipantsList(self._contribution.getCoAuthorList()),
470                    self._getParticipantsList(self._contribution.getSpeakerList())]
471        else:
472            return self._getParticipantsList(self._contribution.getSpeakerList())
473
474class ContributionUpdateAuthorList(ContributionModifBase):
475
476    def _checkParams(self):
477        ContributionModifBase._checkParams(self)
478        self._from= self._pm.extract("from", pType=str, allowEmpty=False)
479        self._to= self._pm.extract("to", pType=str, allowEmpty=False)
480        self._item = self._pm.extract("item", pType=str, allowEmpty=False)
481        self._index = self._pm.extract("index", pType=int, allowEmpty=False)
482
483
484    def _getAnswer(self):
485
486        getAuthor = {'inPlacePrimaryAuthors': self._contribution.getPrimaryAuthorById,
487                   'inPlaceCoAuthors': self._contribution.getCoAuthorById,
488                   'inPlaceSpeakers': self._contribution.getSpeakerById}
489        addAuthor = {'inPlacePrimaryAuthors': self._contribution.addPrimaryAuthor,
490                   'inPlaceCoAuthors': self._contribution.addCoAuthor,
491                   'inPlaceSpeakers': self._contribution.addSpeaker}
492        remAuthor = {'inPlacePrimaryAuthors': self._contribution.removePrimaryAuthor,
493                   'inPlaceCoAuthors': self._contribution.removeCoAuthor}
494
495        author = getAuthor[self._from](self._item)
496
497        if self._to != 'inPlaceSpeakers' and self._from != 'inPlaceSpeakers':
498            remAuthor[self._from](author, removeSpeaker=0)
499
500        addAuthor[self._to](author, index=self._index)
501# IF we want to update all the lists (to update the possible repeated authors (e.g. in speakers list)
502#        if self._contribution.getConference().getType() == "conference":
503#            return [self._getParticipantsList(self._contribution.getPrimaryAuthorList()),
504#                    self._getParticipantsList(self._contribution.getCoAuthorList()),
505#                    self._getParticipantsList(self._contribution.getSpeakerList())]
506#        else:
507#            return self._getParticipantsList(self._contribution.getSpeakerList())
508        return True
509
510
511class ContributionReorderAuthorList(ContributionModifBase):
512
513    def _checkParams(self):
514        ContributionModifBase._checkParams(self)
515        self._list= self._pm.extract("list", pType=str, allowEmpty=False)
516        self._item = self._pm.extract("item", pType=str, allowEmpty=False)
517        self._index = self._pm.extract("index", pType=int, allowEmpty=False)
518
519
520    def _getAnswer(self):
521        changePos = {'inPlacePrimaryAuthors': self._contribution.changePosPrimaryAuthor,
522                   'inPlaceCoAuthors': self._contribution.changePosCoAuthor,
523                   'inPlaceSpeakers': self._contribution.changePosSpeaker}
524        getAuthor = {'inPlacePrimaryAuthors': self._contribution.getPrimaryAuthorById,
525                   'inPlaceCoAuthors': self._contribution.getCoAuthorById,
526                   'inPlaceSpeakers': self._contribution.getSpeakerById}
527
528        author = getAuthor[self._list](self._item)
529        changePos[self._list](author, self._index)
530
531        return True
532
533class SubContributionParticipantsBase(ContributionModifBase):
534
535    def _checkParams(self):
536        ContributionModifBase._checkParams(self)
537        self._pm = ParameterManager(self._params)
538        subContribId = self._pm.extract("subContribId", pType=str, allowEmpty=False)
539        self._subContrib = None
540        for subContrib in self._contribution.getSubContributionList():
541            if subContribId == subContrib.getId():
542                self._subContrib = subContrib
543        if self._subContrib == None:
544            raise ServiceError("ERR-SC0", _("Invalid subcontribution id."))
545
546    def _isEmailAlreadyUsed(self, email):
547        for part in self._subContrib.getSpeakerList():
548            if email == part.getEmail():
549                return True
550        return False
551
552
553class SubContributionAddNewParticipant(SubContributionParticipantsBase):
554
555    def _checkParams(self):
556        SubContributionParticipantsBase._checkParams(self)
557        self._userData = self._pm.extract("userData", pType=dict, allowEmpty=False)
558        email = self._userData.get("email", "")
559        if email != "" and self._isEmailAlreadyUsed(email):
560            raise ServiceAccessError(_("The email address is already used by another participant or the user is already added to the list. Participant not added."))
561
562    def _newParticipant(self):
563        spk = conference.SubContribParticipation()
564        spk.setTitle(self._userData.get("title", ""))
565        spk.setFirstName(self._userData.get("firstName", ""))
566        spk.setFamilyName(self._userData.get("familyName", ""))
567        spk.setAffiliation(self._userData.get("affiliation", ""))
568        spk.setEmail(self._userData.get("email", ""))
569        spk.setAddress(self._userData.get("address", ""))
570        spk.setPhone(self._userData.get("phone", ""))
571        spk.setFax(self._userData.get("fax", ""))
572        self._subContrib.newSpeaker(spk)
573
574
575    def _getAnswer(self):
576        self._newParticipant()
577        return fossilize(self._subContrib.getSpeakerList(), ISubContribParticipationFullFossil)
578
579
580class SubContributionAddExistingParticipant(SubContributionParticipantsBase):
581
582    def _checkParams(self):
583        SubContributionParticipantsBase._checkParams(self)
584        self._userList = self._pm.extract("userList", pType=list, allowEmpty=False)
585        # Check if there is already a user with the same email
586        for user in self._userList:
587            if user["email"] != "" and self._isEmailAlreadyUsed(user["email"]):
588                raise ServiceAccessError(_("The email address (%s) of a user you are trying to add is already used by another participant or the user is already added to the list. Participant(s) not added.") % user["email"])
589
590    def _getAnswer(self):
591        ah = AvatarHolder()
592        for user in self._userList:
593            spk = conference.SubContribParticipation()
594            spk.setDataFromAvatar(ah.getById(user["id"]))
595            self._subContrib.newSpeaker(spk)
596        return fossilize(self._subContrib.getSpeakerList(), ISubContribParticipationFullFossil)
597
598
599class SubContributionRemoveParticipant(SubContributionParticipantsBase):
600
601    def _checkParams(self):
602        SubContributionParticipantsBase._checkParams(self)
603        self._participant = self._subContrib.getSpeakerById(self._pm.extract("userId", pType=str, allowEmpty=False))
604        if self._participant == None:
605            raise ServiceError("ERR-U0", _("User does not exist."))
606
607    def _getAnswer(self):
608        self._subContrib.removeSpeaker(self._participant)
609        return fossilize(self._subContrib.getSpeakerList(), ISubContribParticipationFullFossil)
610
611
612class SubContributionAddAuthorAsPresenter(SubContributionAddExistingParticipant):
613
614    def _newSpeaker(self, author):
615        spk = conference.SubContribParticipation()
616        spk.setTitle(author.getTitle())
617        spk.setFirstName(author.getFirstName())
618        spk.setFamilyName(author.getFamilyName())
619        spk.setAffiliation(author.getAffiliation())
620        spk.setEmail(author.getEmail())
621        spk.setAddress(author.getAddress())
622        spk.setPhone(author.getPhone())
623        spk.setFax(author.getFax())
624        self._subContrib.newSpeaker(spk)
625
626    def _getAnswer(self):
627        for author in self._userList:
628            self._newSpeaker(self._contribution.getAuthorById(author["id"]))
629        return fossilize(self._subContrib.getSpeakerList(), ISubContribParticipationFullFossil)
630
631
632class SubContributionEditParticipantData(SubContributionParticipantsBase):
633
634    def _checkParams(self):
635        SubContributionParticipantsBase._checkParams(self)
636        self._userData = self._pm.extract("userData", pType=dict, allowEmpty=False)
637        self._userId = self._userData.get("id")
638        self._participant = self._subContrib.getSpeakerById(self._userId)
639        if self._participant == None:
640            raise ServiceError("ERR-U0", _("User does not exist."))
641        if self._userData.get("email", "") != "" and self._isEmailAlreadyUsed():
642            raise ServiceAccessError(_("The email address is already used by another participant. Participant not modified."))
643
644    def _isEmailAlreadyUsed(self):
645        for auth in self._subContrib.getSpeakerList():
646            # check if the email is already used by other different speaker
647            if self._userData.get("email", "") == auth.getEmail() and self._userId != str(auth.getId()):
648                return True
649        return False
650
651    def _editParticipant(self):
652        self._participant.setTitle(self._userData.get("title", ""))
653        self._participant.setFirstName(self._userData.get("firstName", ""))
654        self._participant.setFamilyName(self._userData.get("familyName", ""))
655        self._participant.setEmail(self._userData.get("email", ""))
656        self._participant.setAffiliation(self._userData.get("affiliation", ""))
657        self._participant.setAddress(self._userData.get("address", ""))
658        self._participant.setPhone(self._userData.get("phone", ""))
659        self._participant.setFax(self._userData.get("fax", ""))
660
661    def _getAnswer(self):
662        self._editParticipant()
663        return fossilize(self._subContrib.getSpeakerList(), ISubContribParticipationFullFossil)
664
665
666class ContributionSubmittersBase(ContributionModifBase):
667
668    def _checkParams(self):
669        ContributionModifBase._checkParams(self)
670        self._pm = ParameterManager(self._params)
671
672    def _getSubmittersList(self):
673        result = []
674        for submitter in self._contribution.getSubmitterList():
675            submitterFossil = fossilize(submitter)
676            if isinstance(submitter, Avatar):
677                isSpeaker = False
678                if self._conf.getType() == "conference":
679                    isPrAuthor = False
680                    isCoAuthor = False
681                    if self._contribution.isPrimaryAuthorByEmail(submitter.getEmail()):
682                        isPrAuthor = True
683                    if self._contribution.isCoAuthorByEmail(submitter.getEmail()):
684                        isCoAuthor = True
685                    submitterFossil["isPrAuthor"] = isPrAuthor
686                    submitterFossil["isCoAuthor"] = isCoAuthor
687                if self._contribution.isSpeakerByEmail(submitter.getEmail()):
688                    isSpeaker = True
689                submitterFossil["isSpeaker"] = isSpeaker
690            result.append(submitterFossil)
691        # get pending users
692        for email in self._contribution.getSubmitterEmailList():
693            pendingUser = {}
694            pendingUser["email"] = email
695            pendingUser["pending"] = True
696            result.append(pendingUser)
697        return result
698
699
700class ContributionAddExistingSubmitter(ContributionSubmittersBase):
701
702    def _checkParams(self):
703        ContributionSubmittersBase._checkParams(self)
704        self._userList = self._pm.extract("userList", pType=list, allowEmpty=False)
705
706    def _getAnswer(self):
707        ah = PrincipalHolder()
708        for user in self._userList:
709            av = ah.getById(user["id"])
710            self._contribution.grantSubmission(av)
711        return self._getSubmittersList()
712
713
714class ContributionRemoveSubmitter(ContributionSubmittersBase):
715
716    def _checkParams(self):
717        ContributionSubmittersBase._checkParams(self)
718        self._submitterId = self._pm.extract("userId", pType=str, allowEmpty=False)
719        self._kindOfUser = self._pm.extract("kindOfUser", pType=str, allowEmpty=True, defaultValue=None)
720
721    def _getAnswer(self):
722        if self._kindOfUser == "pending":
723            # remove pending email, self._submitterId is an email address
724            self._contribution.revokeSubmissionEmail(self._submitterId)
725        else:
726            ah = PrincipalHolder()
727            av = ah.getById(self._submitterId)
728            if av is not None:
729                # remove submitter
730                self._contribution.revokeSubmission(av)
731            else:
732                raise ServiceError("ERR-U0", _("User does not exist."))
733        return self._getSubmittersList()
734
735
736class ContributionSumissionControlModifyUserRol(ContributionSubmittersBase):
737
738    def _checkParams(self):
739        ContributionSubmittersBase._checkParams(self)
740        self._submitterId = self._pm.extract("userId", pType=str, allowEmpty=False)
741        self._kindOfList = self._pm.extract("kindOfList", pType=str, allowEmpty=False)
742
743
744class ContributionSumissionControlAddAsAuthor(ContributionSumissionControlModifyUserRol):
745
746    def _newParticipant(self, a):
747        part = conference.ContributionParticipation()
748        part.setTitle(a.getTitle())
749        part.setFirstName(a.getName())
750        part.setFamilyName(a.getSurName())
751        part.setAffiliation(a.getOrganisation())
752        part.setEmail(a.getEmail())
753        part.setAddress(a.getAddress())
754        part.setPhone(a.getTelephone())
755        part.setFax(a.getFax())
756        if self._kindOfList == "prAuthor":
757            self._contribution.addPrimaryAuthor(part)
758        elif self._kindOfList == "coAuthor":
759            self._contribution.addCoAuthor(part)
760        elif self._kindOfList == "speaker":
761            self._contribution.newSpeaker(part)
762
763    def _getAnswer(self):
764        ah = AvatarHolder()
765        av = ah.getById(self._submitterId)
766        self._newParticipant(av)
767        return self._getSubmittersList()
768
769
770class ContributionSumissionControlRemoveAsAuthor(ContributionSumissionControlModifyUserRol):
771
772    def _getParticipantByEmail(self, email):
773        if self._kindOfList == "prAuthor":
774            for prAuthor in self._contribution.getPrimaryAuthorList():
775                if prAuthor.getEmail() == email:
776                    return prAuthor
777        elif self._kindOfList == "coAuthor":
778            for coAuthor in self._contribution.getCoAuthorList():
779                if coAuthor.getEmail() == email:
780                    return coAuthor
781        elif self._kindOfList == "speaker":
782            for speaker in self._contribution.getSpeakerList():
783                if speaker.getEmail() == email:
784                    return speaker
785        else:
786            raise ServiceError("ERR-UK0", _("Invalid kind of list of users."))
787        # user not found
788        raise ServiceError("ERR-USC", _("User not found in the list."))
789
790
791    def _getAnswer(self):
792        ah = AvatarHolder()
793        av = ah.getById(self._submitterId)
794        participant = self._getParticipantByEmail(av.getEmail())
795
796        if self._kindOfList == "prAuthor":
797            self._contribution.removePrimaryAuthor(participant, removeSpeaker=0)
798        elif self._kindOfList == "coAuthor":
799            self._contribution.removeCoAuthor(participant, removeSpeaker=0)
800        elif self._kindOfList == "speaker":
801            self._contribution.removeSpeaker(participant)
802        return self._getSubmittersList()
803
804
805class ContributionManagerListBase(ContributionModifBase):
806
807    def _getManagersList(self):
808        result = fossilize(self._contribution.getManagerList())
809        # get pending users
810        for email in self._contribution.getAccessController().getModificationEmail():
811            pendingUser = {}
812            pendingUser["email"] = email
813            pendingUser["pending"] = True
814            result.append(pendingUser)
815        return result
816
817
818class ContributionAddExistingManager(ContributionManagerListBase):
819
820    def _checkParams(self):
821        ContributionManagerListBase._checkParams(self)
822        self._userList = self._pm.extract("userList", pType=list, allowEmpty=False)
823
824    def _getAnswer(self):
825        ph = PrincipalHolder()
826        for user in self._userList:
827            self._contribution.grantModification(ph.getById(user["id"]))
828        return self._getManagersList()
829
830
831class ContributionRemoveManager(ContributionManagerListBase):
832
833    def _checkParams(self):
834        ContributionManagerListBase._checkParams(self)
835        self._managerId = self._pm.extract("userId", pType=str, allowEmpty=False)
836
837    def _getAnswer(self):
838        ph = PrincipalHolder()
839        self._contribution.revokeModification(ph.getById(self._managerId))
840        return self._getManagersList()
841
842
843class ContributionReviewHistory(ContributionDisplayBase):
844
845    def _getAnswer(self):
846        return contributionReviewing.WContributionReviewingHistory(self._contribution).getHTML({"ShowReviewingTeam" : False})
847
848methodMap = {
849    "addSubContribution": ContributionAddSubContribution,
850    "deleteSubContribution": ContributionDeleteSubContribution,
851    "getBooking": ContributionGetBooking,
852    "protection.getAllowedUsersList": ContributionProtectionUserList,
853    "protection.addAllowedUsers": ContributionProtectionAddUsers,
854    "protection.removeAllowedUser": ContributionProtectionRemoveUser,
855
856    "participants.addNewParticipant": ContributionAddNewParticipant,
857    "participants.addExistingParticipant": ContributionAddExistingParticipant,
858    "participants.editParticipantData": ContributionEditParticipantData,
859    "participants.removeParticipant": ContributionRemoveParticipant,
860    "participants.sendEmailData": ContributionSendEmailData,
861    "participants.changeSubmissionRights": ContributionChangeSubmissionRights,
862    "participants.updateAuthorList": ContributionUpdateAuthorList,
863    "participants.reorderAuthorList": ContributionReorderAuthorList,
864
865    "participants.subContribution.addNewParticipant": SubContributionAddNewParticipant,
866    "participants.subContribution.addExistingParticipant": SubContributionAddExistingParticipant,
867    "participants.subContribution.editParticipantData": SubContributionEditParticipantData,
868    "participants.subContribution.removeParticipant": SubContributionRemoveParticipant,
869    "participants.subContribution.addAuthorAsPresenter": SubContributionAddAuthorAsPresenter,
870
871    "protection.submissionControl.addExistingSubmitter": ContributionAddExistingSubmitter,
872    "protection.submissionControl.removeSubmitter": ContributionRemoveSubmitter,
873    "protection.submissionControl.addAsAuthor": ContributionSumissionControlAddAsAuthor,
874    "protection.submissionControl.removeAsAuthor": ContributionSumissionControlRemoveAsAuthor,
875
876    "protection.addExistingManager": ContributionAddExistingManager,
877    "protection.removeManager": ContributionRemoveManager,
878    "review.getReviewHistory": ContributionReviewHistory
879}
Note: See TracBrowser for help on using the repository browser.