source: indico/indico/MaKaC/services/implementation/schedule.py @ 67aa0b

ipv6v0.98-seriesv0.98.2v0.98.3v0.99v1.0v1.1
Last change on this file since 67aa0b was 67aa0b, checked in by Pedro Ferreira <jose.pedro.ferreira@…>, 11 months ago

[FIX] Fix create events if not RB active
  • Property mode set to 100644
File size: 58.5 KB
Line 
1"""
2Schedule-related services
3"""
4
5from MaKaC.services.implementation.base import ParameterManager
6
7import MaKaC.conference as conference
8import MaKaC.schedule as schedule
9
10from MaKaC.common.PickleJar import DictPickler
11from MaKaC.common.fossilize import fossilize
12from MaKaC.fossils.schedule import IConferenceScheduleDisplayFossil
13
14from MaKaC.services.interface.rpc.common import ServiceError, TimingNoReportError,\
15    NoReportError
16
17from MaKaC.services.implementation import conference as conferenceServices
18from MaKaC.services.implementation import base
19from MaKaC.services.implementation import roomBooking
20from MaKaC.services.implementation import session as sessionServices
21from MaKaC.common.timezoneUtils import setAdjustedDate
22from MaKaC.common.utils import getHierarchicalId, formatTime, formatDateTime, parseDate
23from MaKaC.common.contextManager import ContextManager
24import MaKaC.common.info as info
25from MaKaC.errors import TimingError
26from MaKaC.fossils.schedule import ILinkedTimeSchEntryMgmtFossil, IBreakTimeSchEntryMgmtFossil, \
27        IContribSchEntryMgmtFossil
28from MaKaC.fossils.contribution import IContributionParticipationTTMgmtFossil, IContributionFossil
29from MaKaC.fossils.conference import IConferenceParticipationFossil,\
30    ISessionFossil
31from MaKaC.common import timezoneUtils
32from MaKaC.common.Conversion import Conversion
33from MaKaC.schedule import BreakTimeSchEntry
34from MaKaC.conference import SessionSlot, Material, Link
35from MaKaC.webinterface.pages.sessions import WSessionICalExport
36from MaKaC.webinterface.pages.contributions import WContributionICalExport
37from indico.web.http_api.util import generate_public_auth_request
38
39import time, datetime, pytz, copy
40
41def translateAutoOps(autoOps):
42
43    result = []
44
45    for source,op,target, newValue in autoOps:
46
47        if type(newValue) == datetime.datetime:
48            finalTime = formatTime(newValue)
49        else:
50            finalTime = newValue
51
52        result.append((getHierarchicalId(source),
53                       op,
54                       getHierarchicalId(target),
55                       finalTime))
56    return result
57
58
59class ConferenceGetSchedule(conferenceServices.ConferenceDisplayBase):
60    def _checkParams(self):
61        conferenceServices.ConferenceDisplayBase._checkParams(self)
62
63    def _getAnswer(self):
64        #TODO: tz = timezoneUtils.DisplayTZ(self._getAW()).getDisplayTZ() // use it in the fossilize?
65        return self._target.getSchedule().fossilize(IConferenceScheduleDisplayFossil)
66
67class LocationSetter:
68    def _setLocationInfo(self, target):
69        room = self._roomInfo.get('room', None)
70        address = self._roomInfo.get('address', None)
71        location = self._roomInfo.get('location', None)
72        if location != None:
73            loc = target.getOwnLocation()
74            if not loc:
75                loc = conference.CustomLocation()
76            target.setLocation(loc)
77            loc.setName(location)
78            loc.setAddress(address)
79
80        #same as for the location
81        if room != None:
82            r = target.getOwnRoom()
83            if not r:
84                r = conference.CustomRoom()
85            target.setRoom(r)
86            r.setName(room)
87            minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
88            if minfo.getRoomBookingModuleActive():
89                r.retrieveFullName(location)
90            else:
91                # invalidate full name, as we have no way to know it
92                r.fullName = None
93
94class ScheduleOperation:
95
96    def _getAnswer(self):
97
98        self.initializeAutoOps()
99
100        try:
101            return self._performOperation()
102        except TimingError, e:
103            raise TimingNoReportError(e.getMsg())
104
105    def initializeAutoOps(self):
106        ContextManager.set('autoOps',[])
107
108    def getAutoOps(self):
109        return ContextManager.get('autoOps')
110
111
112class ScheduleAddContribution(ScheduleOperation, LocationSetter):
113
114    def __addPeople(self, contribution, pManager, elemType, method):
115        """ Generic method for adding presenters, authors and
116        co-authors. """
117
118        pList = pManager.extract("%ss" % elemType, pType=list,
119                                 allowEmpty=True)
120
121        for elemValues in pList:
122            element = conference.ContributionParticipation()
123            DictPickler.update(element, elemValues)
124
125            # call the appropriate method
126            method(contribution, element)
127
128            if self._privileges is not None:
129                if self._privileges.get('%s-grant-submission' % elemType, False):
130                    contribution.grantSubmission(element)
131
132    def _checkParams(self):
133        self._pManager = ParameterManager(self._params)
134
135        self._roomInfo = self._pManager.extract("roomInfo", pType=dict, allowEmpty=True)
136        self._keywords = self._pManager.extract("keywords", pType=list,
137                                          allowEmpty=True)
138        self._boardNumber = self._pManager.extract("boardNumber", pType=str, allowEmpty=True, defaultValue="")
139        self._reportNumbers = self._pManager.extract("reportNumbers", pType=list, allowEmpty=True, defaultValue=[])
140
141        self._needsToBeScheduled = self._params.get("schedule", True)
142        if self._needsToBeScheduled:
143            self._dateTime = self._pManager.extract("startDate", pType=datetime.datetime)
144
145        self._duration = self._pManager.extract("duration", pType=int)
146        self._title = self._pManager.extract("title", pType=str)
147        self._fields = {}
148
149        for field in self._target.getConference().getAbstractMgr().getAbstractFieldsMgr().getFields():
150            self._fields[field.getId()] = self._pManager.extract("field_%s"%field.getId(), pType=str,
151                                                     allowEmpty=True, defaultValue='')
152        self._privileges = self._pManager.extract("privileges", pType=dict,                                                  allowEmpty=True)
153        self._contribTypeId = self._pManager.extract("type", pType=str, allowEmpty=True)
154        self._materials = self._pManager.extract("materials", pType=dict, allowEmpty=True)
155
156    def _performOperation(self):
157
158        contribution = conference.Contribution()
159
160        self._addToParent(contribution)
161
162        contribution.setTitle(self._title, notify = False)
163
164        contribution.setKeywords('\n'.join(self._keywords))
165
166        contribution.setBoardNumber(self._boardNumber)
167        contribution.setDuration(self._duration/60, self._duration%60)
168
169        if self._reportNumbers:
170            for reportTuple in self._reportNumbers:
171                for recordNumber in reportTuple[1]:
172                    contribution.getReportNumberHolder().addReportNumber(reportTuple[0], recordNumber)
173
174        if self._needsToBeScheduled:
175            checkFlag = self._getCheckFlag()
176            adjDate = setAdjustedDate(self._dateTime, self._conf)
177            contribution.setStartDate(adjDate, check = checkFlag)
178
179        if self._materials:
180            for material in self._materials.keys():
181                newMaterial = Material()
182                newMaterial.setTitle(material)
183                for resource in self._materials[material]:
184                    newLink = Link()
185                    newLink.setURL(resource)
186                    newLink.setName(resource)
187                    newMaterial.addResource(newLink)
188                contribution.addMaterial(newMaterial)
189
190        self._schedule(contribution)
191
192        for field, value in self._fields.iteritems():
193            contribution.setField(field, value)
194
195        if (self._target.getConference().getType() == "conference"):
196            # for conferences, add authors and coauthors
197            self.__addPeople(contribution, self._pManager, "author", conference.Contribution.addPrimaryAuthor)
198            self.__addPeople(contribution, self._pManager, "coauthor", conference.Contribution.addCoAuthor)
199            # and also set type if it exists
200            if (self._contribTypeId):
201                contribution.setType(self._target.getConference().getContribTypeById(self._contribTypeId))
202
203
204        self.__addPeople(contribution, self._pManager, "presenter", conference.Contribution.newSpeaker)
205
206        self._setLocationInfo(contribution)
207
208        schEntry = contribution.getSchEntry()
209        fossilizedData = schEntry.fossilize({"MaKaC.schedule.LinkedTimeSchEntry": ILinkedTimeSchEntryMgmtFossil,
210                                               "MaKaC.schedule.BreakTimeSchEntry" : IBreakTimeSchEntryMgmtFossil,
211                                               "MaKaC.schedule.ContribSchEntry"   : IContribSchEntryMgmtFossil},
212                                            tz=self._conf.getTimezone())
213        fossilizedDataSlotSchEntry = self._getSlotEntry()
214
215        result = {'id': fossilizedData['id'],
216                'entry': fossilizedData,
217                'slotEntry': fossilizedDataSlotSchEntry,
218                'autoOps': translateAutoOps(self.getAutoOps())}
219
220        if self._needsToBeScheduled:
221            result['day'] = schEntry.getAdjustedStartDate().strftime("%Y%m%d")
222
223        return result
224
225
226class ConferenceScheduleAddContribution(ScheduleAddContribution, conferenceServices.ConferenceModifBase):
227
228    def _checkParams(self):
229        conferenceServices.ConferenceModifBase._checkParams(self)
230        ScheduleAddContribution._checkParams(self)
231
232    def _addToParent(self, contribution):
233        self._target.addContribution( contribution )
234        contribution.setParent(self._target)
235
236    def _schedule(self, contribution):
237        if self._needsToBeScheduled:
238            self._target.getSchedule().addEntry(contribution.getSchEntry(), 2)
239
240    def _getSlotEntry(self):
241        return None
242
243
244class SessionSlotScheduleAddContribution(ScheduleAddContribution, sessionServices.SessionSlotModifCoordinationBase):
245
246    def _checkParams(self):
247        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
248        ScheduleAddContribution._checkParams(self)
249
250    def _addToParent(self, contribution):
251        self._session.addContribution( contribution )
252        contribution.setParent(self._session.getConference())
253
254    def _schedule(self, contribution):
255        return  self._slot.getSchedule().addEntry(contribution.getSchEntry(),
256                                                  check = self._getCheckFlag())
257
258    def _getSlotEntry(self):
259        return self._slot.getConfSchEntry().fossilize({"MaKaC.schedule.LinkedTimeSchEntry": ILinkedTimeSchEntryMgmtFossil,
260                                               "MaKaC.schedule.BreakTimeSchEntry" : IBreakTimeSchEntryMgmtFossil,
261                                               "MaKaC.schedule.ContribSchEntry"   : IContribSchEntryMgmtFossil},
262                                               tz=self._conf.getTimezone())
263
264
265class ConferenceScheduleAddSession(ScheduleOperation, conferenceServices.ConferenceModifBase, LocationSetter):
266
267    def __addConveners2Slot(self, slot):
268        for convenerValues in self._conveners:
269            convener = conference.SlotChair()
270            DictPickler.update(convener, convenerValues)
271            slot.addConvener(convener)
272
273    def _checkParams(self):
274        conferenceServices.ConferenceModifBase._checkParams(self)
275
276        pManager = ParameterManager(self._params, timezone = self._conf.getTimezone())
277
278        self._roomInfo = pManager.extract("roomInfo", pType=dict, allowEmpty=True)
279        self._conveners = pManager.extract("conveners", pType=list,
280                                           allowEmpty=True)
281        self._startDateTime = pManager.extract("startDateTime",
282                                               pType=datetime.datetime)
283        self._endDateTime = pManager.extract("endDateTime",
284                                             pType=datetime.datetime)
285        self._title = pManager.extract("title", pType=str)
286        self._subtitle = pManager.extract("subtitle", pType=str, allowEmpty=True)
287        self._textColor = pManager.extract("textColor", pType=str)
288        self._bgColor = pManager.extract("bgColor", pType=str)
289        self._description = pManager.extract("description", pType=str,
290                                          allowEmpty=True)
291        self._scheduleType = pManager.extract("sessionType", pType=str,
292                                          allowEmpty=False)
293
294    def _performOperation(self):
295
296        conf = self._target
297        session = conference.Session()
298
299        session.setValues({
300                     "title": self._title or "",
301                     "description": self._description or "",
302                     "sDate": self._startDateTime,
303                     "eDate": self._endDateTime
304                     })
305        conf.addSession(session)
306        session.setScheduleType(self._scheduleType)
307        session.setTextColor(self._textColor)
308        session.setBgColor(self._bgColor)
309
310        slot = conference.SessionSlot(session)
311
312        slot.setTitle(self._subtitle or "")
313        slot.setStartDate(session.getStartDate())
314
315        tz = pytz.timezone(self._conf.getTimezone())
316        if session.getEndDate().astimezone(tz).date() > session.getStartDate().astimezone(tz).date():
317            newEndDate = session.getStartDate().astimezone(tz).replace(hour=23,minute=59).astimezone(timezone('UTC'))
318        else:
319            newEndDate = session.getEndDate()
320        dur = newEndDate - session.getStartDate()
321        if dur > datetime.timedelta(days=1):
322            dur = datetime.timedelta(days=1)
323
324        slot.setDuration(dur=dur)
325        session.addSlot(slot)
326
327        self.__addConveners2Slot(slot)
328        self._setLocationInfo(slot)
329
330        logInfo = session.getLogInfo()
331        logInfo["subject"] =  _("Create new session: %s")%session.getTitle()
332        self._conf.getLogHandler().logAction(logInfo,"Timetable/Session",self._getUser())
333
334        schEntry = slot.getConfSchEntry()
335        fossilizedData = schEntry.fossilize(ILinkedTimeSchEntryMgmtFossil, tz=conf.getTimezone())
336        fossilizedData['entries'] = {}
337
338        self.initializeFilteringCriteria(session.getId(), schEntry.getSchedule().getOwner().getId())
339
340        return {'day': slot.getAdjustedStartDate().strftime("%Y%m%d"),
341                'id': fossilizedData['id'],
342                'entry': fossilizedData,
343                'session': session.fossilize(ISessionFossil, tz=self._conf.getTimezone()),
344                'autoOps': translateAutoOps(self.getAutoOps())}
345
346    def initializeFilteringCriteria(self, sessionId, conferenceId):
347        # Filtering criteria: by default make new session type checked
348        websession = self._getSession()
349        sessionDict = websession.getVar("ContributionFilterConf%s"%conferenceId)
350        if not sessionDict:
351            #Create a new dictionary
352            sessionDict = {}
353        if sessionDict.has_key('sessions'):
354            #Append the new type to the existing list
355            sessionDict['sessions'].append(sessionId)
356            websession._p_changed = 1
357        else:
358            #Create a new entry for the dictionary containing the new type
359            sessionDict['sessions'] = [sessionId]
360
361class ConferenceScheduleDeleteSession(ScheduleOperation, conferenceServices.ConferenceScheduleModifBase):
362
363    def _performOperation(self):
364        sessionSlot = self._schEntry.getOwner()
365        session = sessionSlot.getSession()
366
367        logInfo = session.getLogInfo()
368        logInfo["subject"] = "Deleted session: %s"%session.getTitle()
369        self._conf.getLogHandler().logAction(logInfo,"Timetable/Session",self._getUser())
370
371        self._conf.removeSession(session)
372
373class ConferenceScheduleDeleteContribution(ScheduleOperation, conferenceServices.ConferenceScheduleModifBase):
374
375    def _performOperation(self):
376
377        contrib = self._schEntry.getOwner()
378        logInfo = contrib.getLogInfo()
379
380        if self._conf.getType() == "meeting":
381            logInfo["subject"] =  _("Deleted contribution: %s")%contrib.getTitle()
382            contrib.delete()
383        else:
384            logInfo["subject"] =  _("Unscheduled contribution: %s")%contrib.getTitle()
385        self._conf.getLogHandler().logAction(logInfo,"Timetable/Contribution",self._getUser())
386
387        self._conf.getSchedule().removeEntry(self._schEntry)
388
389class SessionScheduleDeleteSessionSlot(ScheduleOperation, sessionServices.SessionModifUnrestrictedTTCoordinationBase):
390
391    def _performOperation(self):
392        self._session.removeSlot(self._slot)
393
394class SessionScheduleChangeSessionColors(ScheduleOperation, sessionServices.SessionModifBase):
395
396    def _checkParams(self):
397        sessionServices.SessionModifBase._checkParams(self)
398
399        try:
400            self._bgColor = self._params["bgColor"]
401            self._textColor = self._params["textColor"]
402        except:
403            raise ServiceError("ERR-S4", "Color parameters not provided.")
404
405    def _performOperation(self):
406        self._session.setBgColor(self._bgColor)
407        self._session.setTextColor(self._textColor)
408
409class ScheduleEditBreakBase(ScheduleOperation, LocationSetter):
410
411    def _checkParams(self):
412
413        pManager = ParameterManager(self._params, timezone = self._conf.getTimezone())
414
415        self._roomInfo = pManager.extract("roomInfo", pType=dict, allowEmpty=True)
416        self._dateTime = pManager.extract("startDate", pType=datetime.datetime)
417        self._duration = pManager.extract("duration", pType=int)
418        self._title = pManager.extract("title", pType=str)
419        self._description = pManager.extract("description", pType=str,
420                                          allowEmpty=True)
421        self._textColor = pManager.extract("textColor", pType=str)
422        self._bgColor = pManager.extract("bgColor", pType=str)
423        self._oldId = None
424
425    def _performOperation(self):
426
427        self._brk.setValues({"title": self._title or "",
428                       "description": self._description or "",
429                       "startDate": self._dateTime,
430                       "durMins": str(self._duration),
431                       "durHours": "0"},
432                       check = 2,
433                       tz = self._conf.getTimezone())
434
435        self._brk.setTextColor(self._textColor)
436        self._brk.setBgColor(self._bgColor)
437
438        self._setLocationInfo(self._brk)
439        self._addToSchedule(self._brk)
440
441        fossilizedDataSlotSchEntry = self._getSlotEntry()
442        fossilizedData = self._brk.fossilize(IBreakTimeSchEntryMgmtFossil, tz=self._conf.getTimezone())
443
444        res = {'day': self._brk.getAdjustedStartDate().strftime("%Y%m%d"),
445                'id': fossilizedData['id'],
446                'slotEntry': fossilizedDataSlotSchEntry,
447                'autoOps': translateAutoOps(self.getAutoOps()),
448                'entry': fossilizedData}
449
450        if self._oldId and self._oldId != Conversion.locatorString(self._schEntry)+"b"+self._schEntry.getId():
451            res['oldId'] = self._oldId
452
453        return res
454
455class ConferenceScheduleAddBreak(ScheduleEditBreakBase, conferenceServices.ConferenceModifBase):
456
457    def _checkParams(self):
458        conferenceServices.ConferenceModifBase._checkParams(self)
459        ScheduleEditBreakBase._checkParams(self)
460        self._brk = schedule.BreakTimeSchEntry()
461
462    def _addToSchedule(self, b):
463        self._target.getSchedule().addEntry(b, 2)
464
465    def _getSlotEntry(self):
466        return None
467
468
469class ConferenceScheduleEditBreak(ScheduleEditBreakBase, conferenceServices.ConferenceScheduleModifBase):
470
471    def _checkParams(self):
472        conferenceServices.ConferenceScheduleModifBase._checkParams(self)
473        ScheduleEditBreakBase._checkParams(self)
474        self._brk = self._schEntry
475
476    def _addToSchedule(self, b):
477        pass
478
479    def _getSlotEntry(self):
480        return None
481
482class ConferenceScheduleDeleteBreak(ScheduleOperation, conferenceServices.ConferenceScheduleModifBase):
483
484    def _performOperation(self):
485        self._conf.getSchedule().removeEntry(self._schEntry)
486
487class SessionSlotScheduleAddBreak(ScheduleEditBreakBase, sessionServices.SessionSlotModifCoordinationBase):
488
489    def _checkParams(self):
490        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
491        ScheduleEditBreakBase._checkParams(self)
492        self._brk = schedule.BreakTimeSchEntry()
493
494    def _addToSchedule(self, b):
495        self._slot.getSchedule().addEntry(b, check = self._getCheckFlag())
496
497    def _getSlotEntry(self):
498        return self._slot.getConfSchEntry().fossilize({"MaKaC.schedule.LinkedTimeSchEntry": ILinkedTimeSchEntryMgmtFossil,
499                                               "MaKaC.schedule.BreakTimeSchEntry" : IBreakTimeSchEntryMgmtFossil,
500                                               "MaKaC.schedule.ContribSchEntry"   : IContribSchEntryMgmtFossil},
501                                               tz=self._conf.getTimezone())
502
503
504class SessionSlotScheduleEditBreak(ScheduleEditBreakBase, sessionServices.SessionSlotModifCoordinationBase):
505
506    def _checkParams(self):
507        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
508        ScheduleEditBreakBase._checkParams(self)
509        self._brk = self._schEntry
510        self._oldStartDate = self._schEntry.getStartDate().date()
511        self._oldId = Conversion.locatorString(self._schEntry)+"b"+self._schEntry.getId()
512
513    def _addToSchedule(self, b):
514        # if the schedule target day is different from the current
515        if self._oldStartDate != self._dateTime.date():
516
517            # remove the entry
518            self._schEntry.getSchedule().removeEntry(self._schEntry)
519
520            # set it to the new date
521            self._schEntry.setStartDate(self._dateTime)
522            # add it on the new date
523            self._conf.getSchedule().addEntry(self._schEntry, check=2)
524
525    def _getSlotEntry(self):
526        return self._slot.getConfSchEntry().fossilize({"MaKaC.schedule.LinkedTimeSchEntry": ILinkedTimeSchEntryMgmtFossil,
527                                               "MaKaC.schedule.BreakTimeSchEntry" : IBreakTimeSchEntryMgmtFossil,
528                                               "MaKaC.schedule.ContribSchEntry"   : IContribSchEntryMgmtFossil},
529                                               tz=self._conf.getTimezone())
530
531
532class SessionSlotScheduleDeleteBreak(ScheduleOperation, sessionServices.SessionSlotModifCoordinationBase):
533
534    def _checkParams(self):
535        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
536
537    def _performOperation(self):
538        self._slot.getSchedule().removeEntry(self._schEntry)
539
540class SessionSlotScheduleDeleteContribution(ScheduleOperation, sessionServices.SessionSlotModifCoordinationBase):
541
542    def _checkParams(self):
543        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
544
545    def _performOperation(self):
546
547        contrib = self._schEntry.getOwner()
548
549        logInfo = contrib.getLogInfo()
550
551        if type == "meeting":
552            logInfo["subject"] = "Deleted contribution: %s" %contrib.getTitle()
553            contrib.delete()
554        else:
555            logInfo["subject"] = "Unscheduled contribution: %s"%contrib.getTitle()
556
557        self._slot.getSchedule().removeEntry(self._schEntry)
558        self._conf.getLogHandler().logAction(logInfo,"Timetable/Contribution",self._getUser())
559        self._slot.getSchedule().removeEntry(self._schEntry)
560
561
562class ModifyStartEndDate(ScheduleOperation):
563
564    def _checkParams(self):
565
566        pManager = ParameterManager(self._params, timezone = self._conf.getTimezone())
567        self._startDate = pManager.extract("startDate", pType=datetime.datetime)
568        self._endDate = pManager.extract("endDate", pType=datetime.datetime)
569        self._reschedule = pManager.extract("reschedule", pType=bool)
570
571    def _performOperation(self):
572
573        checkFlag = self._getCheckFlag()
574
575        # if we want to reschedule other entries, let's store the old parameters
576        # and the list of entries that will be rescheduled (after this one)
577
578        if self._reschedule:
579            oldStartDate=copy.copy(self._schEntry.getStartDate())
580            oldDuration=copy.copy(self._schEntry.getDuration())
581            i = self._schEntry.getSchedule().getEntries().index(self._schEntry) + 1
582            lentries = len(self._schEntry.getSchedule().getEntries())
583            while i < lentries and self._schEntry.getStartDate() >= self._schEntry.getSchedule().getEntries()[i].getStartDate():
584                i += 1
585            j = i
586            while j < lentries and self._schEntry.getAdjustedStartDate().date() == \
587                      self._schEntry.getSchedule().getEntries()[j].getAdjustedStartDate().date():
588                j += 1
589            entriesList = self._schEntry.getSchedule().getEntries()[i:j]
590
591        duration = self._endDate - self._startDate
592        owner = self._schEntry.getOwner()
593        if isinstance(owner, SessionSlot) and owner.getSession().getScheduleType() == "poster":
594            # If it is a poster session we must modify the size of all the contributions inside it.
595            for entry in owner.getSchedule().getEntries():
596                entry.setDuration(dur=duration, check=0)
597        # The order to set the start date and duration is important, please keep it like this.
598        # Otherwise, by modifying the startDate we might find entries inside a slot that are
599        # temporarly outside and an exception will be raised.
600        self._schEntry.setDuration(dur=duration,check=checkFlag)
601        self._schEntry.setStartDate(self._startDate, moveEntries=1, check=checkFlag)
602
603        # In case of 'reschedule', calculate the time difference
604        if self._reschedule:
605            diff = (self._schEntry.getStartDate() - oldStartDate) + (self._schEntry.getDuration() - oldDuration)
606
607            # shift accordingly
608            self._schEntry.getSchedule().moveEntriesBelow(diff, entriesList)
609
610            # retrieve results
611            fossilizedData = schedule.ScheduleToJson.process(self._schEntry.getSchedule(), self._conf.getTimezone(),
612                                                          None, days = [self._schEntry.getAdjustedStartDate()],
613                                                          mgmtMode = True)
614            entryId = fossilizedData.keys()[0]
615            fossilizedData = fossilizedData.values()[0]
616        else:
617            entryId, fossilizedData = schedule.ScheduleToJson.processEntry(self._schEntry, self._conf.getTimezone(),
618                                                                        None, mgmtMode = True)
619
620        return {'day': self._schEntry.getAdjustedStartDate().strftime("%Y%m%d"),
621                'id': entryId,
622                'entry': fossilizedData,
623                'autoOps': translateAutoOps(self.getAutoOps())}
624
625
626class SessionSlotScheduleModifyStartEndDate(ModifyStartEndDate, sessionServices.SessionSlotModifCoordinationBase):
627
628    def _checkParams(self):
629        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
630        ModifyStartEndDate._checkParams(self)
631        pm = ParameterManager(self._params)
632        self._isSessionTimetable = pm.extract("sessionTimetable", pType=bool, allowEmpty=True)
633
634
635    def _performOperation(self):
636
637        result = ModifyStartEndDate._performOperation(self)
638
639        if self._isSessionTimetable:
640            schEntry = self._slot.getSessionSchEntry()
641        else:
642            schEntry = self._slot.getConfSchEntry()
643
644        fossilizedDataSlotSchEntry = schEntry.fossilize({"MaKaC.schedule.LinkedTimeSchEntry": ILinkedTimeSchEntryMgmtFossil,
645                                               "MaKaC.schedule.BreakTimeSchEntry" : IBreakTimeSchEntryMgmtFossil,
646                                               "MaKaC.schedule.ContribSchEntry"   : IContribSchEntryMgmtFossil},
647                                               tz=self._conf.getTimezone())
648        fossilizedDataSession = self._session.fossilize(ISessionFossil, tz=self._conf.getTimezone())
649        result.update({'slotEntry': fossilizedDataSlotSchEntry,
650                       'session': fossilizedDataSession})
651
652        return result
653
654
655class ConferenceScheduleModifyStartEndDate(ModifyStartEndDate, conferenceServices.ConferenceScheduleModifBase):
656
657   def _checkParams(self):
658        conferenceServices.ConferenceScheduleModifBase._checkParams(self)
659        ModifyStartEndDate._checkParams(self)
660
661
662class SessionScheduleModifyStartEndDate(ModifyStartEndDate, sessionServices.SessionModifUnrestrictedTTCoordinationBase):
663
664   def _checkParams(self):
665        sessionServices.SessionModifUnrestrictedTTCoordinationBase._checkParams(self)
666        ModifyStartEndDate._checkParams(self)
667
668class ConferenceScheduleGetDayEndDate(ScheduleOperation, conferenceServices.ConferenceModifBase):
669
670    def _checkParams(self):
671        conferenceServices.ConferenceModifBase._checkParams(self)
672        pManager = ParameterManager(self._params)
673
674        date = pManager.extract("selectedDay", pType=datetime.date)
675        self._date = datetime.datetime(date.year, date.month, date.day, tzinfo=pytz.timezone(self._conf.getTimezone()))
676
677    def _performOperation(self):
678        return self._target.getSchedule().calculateDayEndDate(self._date).strftime('%Y/%m/%d %H:%M')
679
680class SessionSlotScheduleGetDayEndDate(ScheduleOperation, sessionServices.SessionSlotModifCoordinationBase):
681
682    def _checkParams(self):
683        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
684        pManager = ParameterManager(self._params)
685        date = pManager.extract("selectedDay", pType=datetime.date)
686        self._date = datetime.datetime(date.year, date.month, date.day, tzinfo=pytz.timezone(self._conf.getTimezone()))
687
688    def _performOperation(self):
689        eDate = self._slot.getSchedule().calculateDayEndDate(self._date)
690        return eDate.strftime('%Y/%m/%d %H:%M')
691
692class SessionSlotGetFossil(sessionServices.SessionSlotDisplayBase):
693
694    def _getAnswer(self):
695        return fossilize(self._slot)
696
697class SessionSlotGetBooking(ScheduleOperation, sessionServices.SessionSlotDisplayBase, roomBooking.GetBookingBase):
698    def _performOperation(self):
699        return self._getRoomInfo(self._target)
700
701class SessionScheduleGetDayEndDate(ScheduleOperation, sessionServices.SessionModifUnrestrictedTTCoordinationBase):
702
703    def _checkParams(self):
704        sessionServices.SessionModifUnrestrictedTTCoordinationBase._checkParams(self)
705        pManager = ParameterManager(self._params)
706
707        date = pManager.extract("selectedDay", pType=datetime.date)
708        self._date = datetime.datetime(date.year, date.month, date.day)
709
710    def _performOperation(self):
711        eDate = self._target.getSchedule().calculateDayEndDate(self._date)
712        return eDate.strftime('%Y/%m/%d %H:%M')
713
714class ScheduleEditSlotBase(ScheduleOperation, LocationSetter):
715
716    def _addConveners(self, slot):
717        pass
718
719    def _setSessionTitle(self, slot):
720        pass
721
722    def _checkParams(self):
723        self.pManager = ParameterManager(self._params)
724
725        self._startDateTime = self.pManager.extract("startDateTime",
726                                               pType=datetime.datetime)
727        self._endDateTime = self.pManager.extract("endDateTime",
728                                             pType=datetime.datetime)
729        self._title = self.pManager.extract("title", pType=str, allowEmpty=True)
730        self._conveners = self.pManager.extract("conveners", pType=list,
731                                           allowEmpty=True)
732        self._roomInfo = self.pManager.extract("roomInfo", pType=dict, allowEmpty=True)
733        self._isSessionTimetable = self.pManager.extract("sessionTimetable", pType=bool, allowEmpty=True)
734
735    def _performOperation(self):
736        #if there is something inside the session we have to move it as well
737
738        values = {"title": self._title or "",
739                  "sDate": self._startDateTime,
740                  "eDate": self._endDateTime}
741
742        if len(self._slot.getEntries()) != 0 :
743            values.update({"move": 1})
744        self._slot.setValues(values)
745
746        self. _addConveners(self._slot)
747        self._setLocationInfo(self._slot)
748        self._setSessionTitle(self._slot)
749
750        self._addToSchedule()
751
752        logInfo = self._slot.getLogInfo()
753        logInfo["subject"] = "Create new slot: %s"%self._slot.getTitle()
754        self._conf.getLogHandler().logAction(logInfo,"Timetable/Contribution",self._getUser())
755
756        if self._isSessionTimetable:
757            schEntry = self._slot.getSessionSchEntry()
758        else:
759            schEntry = self._slot.getConfSchEntry()
760        entryId, fossilizedData = schedule.ScheduleToJson.processEntry(schEntry, self._conf.getTimezone(),
761                                                                    None, mgmtMode = True)
762
763        return {'day': schEntry.getAdjustedStartDate().strftime("%Y%m%d"),
764                'id': fossilizedData['id'],
765                'entry': fossilizedData,
766                'autoOps': translateAutoOps(self.getAutoOps()),
767                'session': self._slot.getSession().fossilize(ISessionFossil, tz=self._conf.getTimezone())}
768
769class SessionScheduleAddSessionSlot(ScheduleEditSlotBase, sessionServices.SessionModifUnrestrictedTTCoordinationBase):
770
771    def _checkParams(self):
772        sessionServices.SessionModifUnrestrictedTTCoordinationBase._checkParams(self)
773        ScheduleEditSlotBase._checkParams(self)
774        self._slot = conference.SessionSlot(self._target)
775
776    def _addToSchedule(self):
777        self._target.addSlot(self._slot)
778
779    def _addConveners(self, slot):
780        for convenerValues in self._conveners:
781            convener = conference.SlotChair()
782            DictPickler.update(convener, convenerValues)
783            slot.addConvener(convener)
784
785class SessionScheduleEditSessionSlot(ScheduleEditSlotBase, sessionServices.SessionModifUnrestrictedTTCoordinationBase):
786
787    def _checkParams(self):
788        sessionServices.SessionModifUnrestrictedTTCoordinationBase._checkParams(self)
789        ScheduleEditSlotBase._checkParams(self)
790        self._sessionTitle = self.pManager.extract("sessionTitle", pType = str, allowEmpty=False)
791
792    def _addToSchedule(self):
793        pass
794
795    def _addConveners(self, slot):
796        convenersIds = []
797        for convenerValues in self._conveners:
798            if convenerValues.has_key("isConfParticipant"):
799                convener = slot.getConvenerById(str(convenerValues['id']))
800                DictPickler.update(convener, convenerValues)
801            else:
802                convener = conference.SlotChair()
803                DictPickler.update(convener, convenerValues)
804                slot.addConvener(convener)
805            convenersIds.append(convener.getId())
806
807        for conv in slot.getConvenerList()[:]:
808            if conv.getId() not in convenersIds:
809                slot.removeConvener(conv)
810
811    def _setSessionTitle(self, slot):
812        slot.getSession().setTitle(self._sessionTitle)
813
814
815class SessionScheduleEditSessionSlotById(SessionScheduleEditSessionSlot):
816    """
817    Edits session slot. Session slot is identified by its id within a session,
818    not like in the parent's class by schedule id.
819    """
820    def _checkParams(self):
821        if self._params.has_key("scheduleEntry"):
822            del self._params["scheduleEntry"]
823        SessionScheduleEditSessionSlot._checkParams(self)
824        self._slot = self._session.slots[self._params["sessionSlotId"]]
825
826
827class ConferenceSetSessionSlots( conferenceServices.ConferenceTextModificationBase ):
828    """
829    Set or unset automatic conflict solving for timetable
830    """
831    def _handleSet(self):
832        if self._value:
833            if not self._target.getEnableSessions():
834                raise ServiceError("ERR-S0", "Sessions must be active for"+
835                                  " session slots to be enabled.")
836            self._target.enableSessionSlots()
837        else:
838            for s in self._target.getSessionList() :
839                if len(s.getSlotList()) > 1 :
840                    raise ServiceError("ERR-S1", "More than one slot defined for session "+
841                                      "'%s'. Cannot disable displaying multiple"
842                                      " session slots." % self._target.getTitle())
843            self._target.disableSessionSlots()
844
845
846    def _handleGet(self):
847        return self._target.getEnableSessionSlots()
848
849class ConferenceSetScheduleSessions( conferenceServices.ConferenceTextModificationBase ):
850    """
851    Set or unset automatic conflict solving for timetable
852    """
853    def _handleSet(self):
854        if self._value:
855            self._target.enableSessions()
856        else:
857            if len(self._target.getSessionList()) > 0 :
858                raise ServiceError("ERR-S2","Sessions already defined. "+
859                                  "Cannot disable them now.")
860            self._target.disableSessions()
861            self._target.disableSessionSlots()
862
863
864    def _handleGet(self):
865        return self._target.getEnableSessions()
866
867class ConferenceGetAllSpeakers(conferenceServices.ConferenceDisplayBase):
868    """
869    Get all speakers from contributions from the event
870    """
871    def _getAnswer(self):
872        d = {}
873        for contribution in self._target.getContributionList() :
874            for elem in contribution.getSpeakerList().fossilize(IContributionParticipationTTMgmtFossil):
875                elem['id'] = "%s.%s" % (contribution.getId(), elem['id'])
876                d[elem['name']] = elem
877        return d.values()
878
879class ConferenceGetAllConveners(conferenceServices.ConferenceDisplayBase):
880    """
881    Get all conveners of sessions from the event
882    """
883    def _getAnswer(self):
884        d = {}
885        for session in self._target.getSessionList() :
886            for elem in session.getConvenerList().fossilize(IConferenceParticipationFossil):
887                elem['id'] = "%s.%s" % (session.getId(), elem['id'])
888                d[elem['name']] = elem
889        return d.values()
890
891### Breaks
892
893class BreakBase(object):
894
895    def _checkParams( self ):
896
897        try:
898            self._target = self._conf = conference.ConferenceHolder().getById(self._params["conference"]);
899            if self._conf == None:
900                raise Exception("Conference id not specified.")
901        except:
902            raise ServiceError("ERR-E4", "Invalid conference id.")
903
904        slotId = self._params.get("slot", None)
905
906        try:
907            if slotId != None:
908                self._slot = self._session.getSlotById(slotId)
909        except Exception, e:
910            raise ServiceError("ERR-S3", "Invalid slot id.",inner=str(e))
911
912        except:
913            raise ServiceError("ERR-C0", "Invalid break id.")
914
915        try:
916            entry = self._params["break"]
917
918            if slotId != None:
919                self._break = self._slot.getSchedule().getEntryById(entry)
920            else:
921                self._break = self._conf.getSchedule().getEntryById(entry)
922
923            if self._break == None:
924                raise Exception("Break id not specified.")
925        except:
926            raise ServiceError("ERR-C0", "Invalid break id.")
927
928
929        # create a parameter manager that checks the consistency of passed parameters
930        self._pm = ParameterManager(self._params)
931
932class BreakDisplayBase(base.ProtectedDisplayService, BreakBase):
933
934    def _checkParams(self):
935        BreakBase._checkParams(self)
936        base.ProtectedDisplayService._checkParams(self)
937
938
939class BreakGetBooking(BreakDisplayBase, roomBooking.GetBookingBase):
940    def _getAnswer(self):
941        return self._getRoomInfo(self._break)
942
943
944class GetUnscheduledContributions(ScheduleOperation):
945
946    """ Returns the list of unscheduled contributions for the target """
947
948    def _performOperation(self):
949        unscheduledList = []
950
951        for contrib in self._target.getContributionList():
952            if self._isScheduled(contrib):
953                continue
954            unscheduledList.append(contrib)
955
956        return fossilize(unscheduledList, IContributionFossil, tz=self._conf.getTimezone())
957
958class ConferenceGetUnscheduledContributions(GetUnscheduledContributions, conferenceServices.ConferenceModifBase):
959
960    def _isScheduled(self, contrib):
961        return contrib.getSession() is not None or \
962               contrib.isScheduled() or \
963               isinstance(contrib.getCurrentStatus(),conference.ContribStatusWithdrawn)
964
965class SessionGetUnscheduledContributions(GetUnscheduledContributions, sessionServices.SessionModifCoordinationBase):
966
967    def _isScheduled(self, contrib):
968        return contrib.isScheduled() or \
969               isinstance(contrib.getCurrentStatus(),conference.ContribStatusWithdrawn)
970
971
972
973class ScheduleContributions(ScheduleOperation):
974
975    """ Schedules the contribution in the timetable of the event"""
976
977    def _checkParams(self):
978        pManager = ParameterManager(self._params,
979                                    timezone = self._target.getTimezone())
980
981        self._ids = pManager.extract("ids", pType=list, allowEmpty=False)
982        date = pManager.extract("date", pType=datetime.date,
983                                            allowEmpty=False)
984
985        # convert date to datetime
986        self._date = pytz.timezone(self._target.getTimezone()).localize(datetime.datetime(*(date.timetuple()[:6]+(0,))))
987
988
989    def _performOperation(self):
990
991        entries = []
992
993        for contribId in self._ids:
994
995            contrib = self._getContributionId(contribId)
996
997            isPoster = self._handlePosterContributions(contrib)
998
999            if not isPoster:
1000                d = self._target.getSchedule().calculateDayEndDate(self._date)
1001                contrib.setStartDate(d)
1002
1003            schEntry = contrib.getSchEntry()
1004
1005            self._target.getSchedule().addEntry(schEntry, check = self._getCheckFlag())
1006
1007            fossilizedData = schEntry.fossilize(IContribSchEntryMgmtFossil, tz=self._conf.getTimezone())
1008            fossilizedDataSlotSchEntry = self._getSlotEntry()
1009
1010            entries.append({'day': schEntry.getAdjustedStartDate().strftime("%Y%m%d"),
1011                            'id': fossilizedData['id'],
1012                            'entry': fossilizedData,
1013                            'slotEntry': fossilizedDataSlotSchEntry,
1014                            'autoOps': translateAutoOps(self.getAutoOps())
1015                            })
1016        return entries
1017
1018class SessionSlotScheduleContributions(ScheduleContributions, sessionServices.SessionSlotModifCoordinationBase):
1019    def _checkParams(self):
1020
1021        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
1022        ScheduleContributions._checkParams(self)
1023
1024        pManager = ParameterManager(self._params,
1025                                    timezone = self._target.getTimezone())
1026
1027        self._isSessionTimetable = pManager.extract("sessionTimetable", pType=bool, allowEmpty=True)
1028
1029
1030    def _getContributionId(self, contribId):
1031        return self._target.getSession().getContributionById(contribId)
1032
1033    def _handlePosterContributions(self, contrib):
1034        if self._slot.getSession().getScheduleType() == "poster":
1035            contrib.setStartDate(self._slot.getStartDate())
1036            contrib.setDuration(dur=self._slot.getDuration())
1037            return True
1038        return False
1039
1040    def _getSlotEntry(self):
1041
1042        if self._isSessionTimetable:
1043            entry = self._slot.getSessionSchEntry()
1044        else:
1045            entry = self._slot.getConfSchEntry()
1046
1047        return entry.fossilize({"MaKaC.schedule.LinkedTimeSchEntry": ILinkedTimeSchEntryMgmtFossil,
1048                                "MaKaC.schedule.BreakTimeSchEntry" : IBreakTimeSchEntryMgmtFossil,
1049                                "MaKaC.schedule.ContribSchEntry"   : IContribSchEntryMgmtFossil},
1050                               tz=self._conf.getTimezone())
1051
1052class ConferenceScheduleContributions(ScheduleContributions, conferenceServices.ConferenceModifBase):
1053    def _checkParams(self):
1054        conferenceServices.ConferenceModifBase._checkParams(self)
1055        ScheduleContributions._checkParams(self)
1056
1057    def _getContributionId(self, contribId):
1058        return self._target.getContributionById(contribId)
1059
1060    def _handlePosterContributions(self, contrib):
1061        pass
1062
1063    def _getSlotEntry(self):
1064        return None
1065
1066class MoveEntryBase(ScheduleOperation):
1067
1068    def _checkParams(self):
1069        pManager = ParameterManager(self._params, timezone = self._conf.getTimezone())
1070        self._contribPlace = pManager.extract("value", pType=str, allowEmpty=False)
1071        self._schEntryId = pManager.extract("scheduleEntryId", pType=int, allowEmpty=False)
1072        self._sessionId = pManager.extract("sessionId", pType=str, allowEmpty=True, defaultValue=None)
1073        self._sessionSlotId = pManager.extract("sessionSlotId", pType=str, allowEmpty=True, defaultValue=None)
1074        self._newTime = pManager.extract("newTime", pType=datetime.datetime, allowEmpty=True, defaultValue=None)
1075
1076    def _performOperation(self):
1077        utc = pytz.timezone('UTC')
1078        if (self._sessionId != None and self._sessionSlotId != None):
1079            self._schEntry = self._conf.getSessionById(self._sessionId).getSlotById(self._sessionSlotId).getSchedule().getEntryById(self._schEntryId)
1080        else:
1081            self._schEntry = self._conf.getSchedule().getEntryById(self._schEntryId)
1082
1083        owner = self._schEntry.getOwner()
1084
1085        if self._contribPlace.strip() != "":
1086            entriesFossilsDict = {"MaKaC.schedule.LinkedTimeSchEntry": ILinkedTimeSchEntryMgmtFossil,
1087                                               "MaKaC.schedule.BreakTimeSchEntry" : IBreakTimeSchEntryMgmtFossil,
1088                                               "MaKaC.schedule.ContribSchEntry"   : IContribSchEntryMgmtFossil}
1089            oldSch = self._schEntry.fossilize(entriesFossilsDict)
1090            oldDate = self._schEntry.getStartDate()
1091            oldSch['startDate'] = formatDateTime(oldDate.astimezone(pytz.timezone(owner.getTimezone())))
1092
1093            sessionId,sessionSlotId = self._contribPlace.split(":")
1094
1095            if sessionId != "conf":
1096                # Moving inside a session
1097                session = self._conf.getSessionById(sessionId)
1098
1099                if session.getScheduleType() == "poster" and isinstance(self._schEntry, BreakTimeSchEntry):
1100                    raise NoReportError(_("It is not possible to move a break inside a poster session"))
1101
1102                if session is not None:
1103                    slot = session.getSlotById(sessionSlotId)
1104                    if slot is not None:
1105                        fossilizedDataSession = session.fossilize(ISessionFossil, tz=self._conf.getTimezone())
1106                        # unschedule entry from previous place
1107                        self._schEntry.getSchedule().removeEntry(self._schEntry)
1108                        if isinstance(owner, conference.Contribution):
1109                            owner.setSession(session)
1110                        if session.getScheduleType() == "poster":
1111                            self._schEntry.setStartDate(slot.getStartDate())
1112                            self._schEntry.setDuration(dur=slot.getDuration())
1113                        else:
1114                            if self._newTime:
1115                                self._schEntry.setStartDate(self._newTime.astimezone(utc))
1116                            else:
1117                                # if we have no clear indication of where we should place this,
1118                                # put it after everything else
1119                                self._schEntry.setStartDate(slot.getSchedule().calculateEndDate())
1120                            #self._schEntry.setDuration(dur=session.getContribDuration())
1121                        # add it to new container
1122                        slot.getSchedule().addEntry(self._schEntry, check=2)
1123                        fossilizedDataSlotSchEntry = slot.getConfSchEntry().fossilize(entriesFossilsDict, tz=self._conf.getTimezone())
1124                    else:
1125                        raise ServiceError("ERR-S3","Invalid slot ID")
1126                else:
1127                    raise ServiceError("ERR-S4","Invalid session ID")
1128            else:
1129                # Moving inside the top-level timetable
1130
1131                fossilizedDataSlotSchEntry = None
1132                if isinstance(owner, conference.Contribution):
1133                    fossilizedDataSession  = owner.getOwner().fossilize(tz=self._conf.getTimezone())
1134                else:
1135                    fossilizedDataSession  = None
1136
1137                # the target date/time
1138                parsedDate = parseDate(sessionSlotId, format="%Y%m%d")
1139
1140                if self._newTime:
1141                    newStartDate = self._newTime.astimezone(utc)
1142                else:
1143                    owner_tz = pytz.timezone(owner.getTimezone())
1144                    newStartDate = owner_tz.localize(datetime.datetime.combine(parsedDate,
1145                                                                               oldDate.astimezone(owner_tz).time())).astimezone(utc)
1146
1147                self._schEntry.getSchedule().removeEntry(self._schEntry)
1148
1149                self._schEntry.setStartDate(newStartDate)
1150                if isinstance(owner, conference.Contribution):
1151                    owner.setSession(None)
1152                self._conf.getSchedule().addEntry(self._schEntry, check=2)
1153
1154        newFossilizedEntry = self._schEntry.fossilize(entriesFossilsDict)
1155        return {'entry': newFossilizedEntry,
1156                'old': oldSch,
1157                'id': newFossilizedEntry['id'],
1158                'day': self._schEntry.getAdjustedStartDate().strftime("%Y%m%d"),
1159                'session': fossilizedDataSession ,
1160                'slotEntry': fossilizedDataSlotSchEntry,
1161                'autoOps': translateAutoOps(self.getAutoOps())}
1162
1163class MoveEntry(MoveEntryBase, conferenceServices.ConferenceModifBase):
1164
1165    def _checkParams(self):
1166        conferenceServices.ConferenceModifBase._checkParams(self)
1167        MoveEntryBase._checkParams(self)
1168
1169class MoveEntryFromSessionBlock(MoveEntryBase, sessionServices.SessionSlotModifCoordinationBase):
1170
1171    def _checkParams(self):
1172        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
1173        MoveEntryBase._checkParams(self)
1174
1175
1176class MoveEntryUpDown(ScheduleOperation):
1177    def _checkParams(self):
1178
1179        pManager = ParameterManager(self._params, timezone = self._conf.getTimezone())
1180        self._direction = pManager.extract("direction", pType=bool, allowEmpty=False)
1181        self._schEntryId = pManager.extract("scheduleEntryId", pType=int, allowEmpty=False)
1182
1183
1184    def _performOperation(self):
1185
1186        sched = self._target.getSchedule()
1187        schEntry = sched.getEntryById(self._schEntryId)
1188
1189        if self._direction:
1190            sched.moveUpEntry(schEntry)
1191        else:
1192            sched.moveDownEntry(schEntry)
1193
1194        return schedule.ScheduleToJson.process(sched, self._conf.getTimezone(), None,
1195                                               days = [ schEntry.getAdjustedStartDate() ],
1196                                               mgmtMode = True)
1197
1198
1199class ConferenceTimetableMoveEntryUpDown(MoveEntryUpDown, conferenceServices.ConferenceModifBase):
1200
1201    def _checkParams(self):
1202        conferenceServices.ConferenceModifBase._checkParams(self)
1203        MoveEntryUpDown._checkParams(self)
1204
1205class SessionSlotTimetableMoveEntryUpDown(MoveEntryUpDown, sessionServices.SessionSlotModifCoordinationBase):
1206
1207    def _checkParams(self):
1208        sessionServices.SessionSlotModifBase._checkParams(self)
1209        MoveEntryUpDown._checkParams(self)
1210
1211class SessionTimetableMoveEntryUpDown(MoveEntryUpDown, sessionServices.SessionModifCoordinationBase):
1212
1213    def _checkParams(self):
1214        sessionServices.SessionModifCoordinationBase._checkParams(self)
1215        MoveEntryUpDown._checkParams(self)
1216
1217
1218class EditRoomLocationBase(ScheduleOperation, LocationSetter):
1219    def _checkParams(self):
1220        self.pManager = ParameterManager(self._params)
1221        self._roomInfo = self.pManager.extract("roomInfo", pType=dict, allowEmpty=True)
1222        self._isSessionTimetable = self.pManager.extract("sessionTimetable", pType=bool, allowEmpty=True)
1223
1224    def _performOperation(self):
1225        self._entry.setRoom(None)
1226        self._entry.setLocation(None)
1227        self._setLocationInfo(self._entry)
1228        entryId, pickledData = schedule.ScheduleToJson.processEntry(self._schEntry, self._conf.getTimezone(),
1229                                                                        None, mgmtMode = True)
1230
1231        return {'day': self._schEntry.getAdjustedStartDate().strftime("%Y%m%d"),
1232                'id': entryId,
1233                'entry': pickledData,
1234                'autoOps': translateAutoOps(self.getAutoOps())}
1235
1236
1237class EventEditRoomLocation(EditRoomLocationBase, conferenceServices.ConferenceScheduleModifBase):
1238
1239    def _checkParams(self):
1240        conferenceServices.ConferenceScheduleModifBase._checkParams(self)
1241        EditRoomLocationBase._checkParams(self)
1242        self._entry = self._schEntry
1243
1244class SessionEditRoomLocation(EditRoomLocationBase, sessionServices.SessionModifUnrestrictedTTCoordinationBase):
1245
1246    def _checkParams(self):
1247        sessionServices.SessionModifUnrestrictedTTCoordinationBase._checkParams(self)
1248        EditRoomLocationBase._checkParams(self)
1249        if not hasattr(self, "_slot"):
1250            self._slot = self._session.slots[self._params["slot"]]
1251        if not hasattr(self, "_schEntry"):
1252            if self._params.get("sessionTimetable", False):
1253                self._schEntry = self._slot._sessionSchEntry
1254            else:
1255                self._schEntry = self._slot._confSchEntry
1256        self._entry = self._slot
1257
1258    def _performOperation(self):
1259        result = EditRoomLocationBase._performOperation(self)
1260
1261        pickledDataSlotSchEntry = fossilize(self._slot.getConfSchEntry(), tz=self._conf.getTimezone())
1262        pickledDataSession = fossilize(self._session, tz=self._conf.getTimezone())
1263        result.update({'slotEntry': pickledDataSlotSchEntry,
1264                       'session': pickledDataSession})
1265
1266        return result
1267
1268class SessionSlotEditRoomLocation(EditRoomLocationBase, sessionServices.SessionSlotModifCoordinationBase):
1269
1270    def _checkParams(self):
1271        sessionServices.SessionSlotModifCoordinationBase._checkParams(self)
1272        EditRoomLocationBase._checkParams(self)
1273        self._entry = self._schEntry
1274
1275    def _performOperation(self):
1276        result = EditRoomLocationBase._performOperation(self)
1277        pickledDataSlotSchEntry = fossilize(self._slot.getConfSchEntry(), tz=self._conf.getTimezone())
1278        pickledDataSession = fossilize(self._session, tz=self._conf.getTimezone())
1279        result.update({'slotEntry': pickledDataSlotSchEntry,
1280                       'session': pickledDataSession})
1281
1282        return result
1283
1284
1285class SessionGetExportPopup(conferenceServices.ConferenceDisplayBase):
1286
1287    def _checkParams(self):
1288        conferenceServices.ConferenceDisplayBase._checkParams(self)
1289        pm = ParameterManager(self._params)
1290        sessionId = pm.extract("sessionId", str, False, "")
1291        self._session = self._conf.getSessionById(sessionId)
1292
1293    def _getAnswer(self):
1294        return WSessionICalExport( self._session, self._getUser() ).getHTML().replace("\n","")
1295
1296class SessionExportURLs(conferenceServices.ConferenceDisplayBase, base.ExportToICalBase):
1297
1298    def _checkParams(self):
1299        conferenceServices.ConferenceDisplayBase._checkParams(self)
1300        base.ExportToICalBase._checkParams(self)
1301        pm = ParameterManager(self._params)
1302        self._sessionId = pm.extract("sessionId", str, False, "")
1303
1304    def _getAnswer(self):
1305        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
1306
1307        return generate_public_auth_request(self._apiMode, self._apiKey, '/export/event/%s/session/%s.ics'%(self._target.getId(), self._sessionId), {}, minfo.isAPIPersistentAllowed() and self._apiKey.isPersistentAllowed(), minfo.isAPIHTTPSRequired())
1308
1309
1310class ContributionGetExportPopup(conferenceServices.ConferenceDisplayBase):
1311
1312    def _checkParams(self):
1313        conferenceServices.ConferenceDisplayBase._checkParams(self)
1314        pm = ParameterManager(self._params)
1315        contribId = pm.extract("contribId", str, False, "")
1316        self._contribution = self._conf.getContributionById(contribId)
1317
1318    def _getAnswer(self):
1319        return WContributionICalExport( self._contribution, self._getUser() ).getHTML().replace("\n","")
1320
1321class ContributionExportURLs(conferenceServices.ConferenceDisplayBase, base.ExportToICalBase):
1322
1323    def _checkParams(self):
1324        conferenceServices.ConferenceDisplayBase._checkParams(self)
1325        base.ExportToICalBase._checkParams(self)
1326        pm = ParameterManager(self._params)
1327        self._contribId = pm.extract("contribId", str, False, "")
1328
1329    def _getAnswer(self):
1330        result = {}
1331
1332        minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance()
1333
1334        urls = generate_public_auth_request(self._apiMode, self._apiKey, '/export/event/%s/contribution/%s.ics'%(self._target.getId(), self._contribId), {}, minfo.isAPIPersistentAllowed() and self._apiKey.isPersistentAllowed(), minfo.isAPIHTTPSRequired())
1335        result["publicRequestURL"] = urls["publicRequestURL"]
1336        result["authRequestURL"] =  urls["authRequestURL"]
1337
1338        return result
1339
1340methodMap = {
1341    "get": ConferenceGetSchedule,
1342
1343    "event.addContribution": ConferenceScheduleAddContribution,
1344    "event.addSession": ConferenceScheduleAddSession,
1345    "event.addBreak": ConferenceScheduleAddBreak,
1346    "event.editBreak": ConferenceScheduleEditBreak,
1347    "event.modifyStartEndDate": ConferenceScheduleModifyStartEndDate,
1348    "event.deleteContribution": ConferenceScheduleDeleteContribution,
1349    "event.deleteSession": ConferenceScheduleDeleteSession,
1350    "event.deleteBreak": ConferenceScheduleDeleteBreak,
1351    "event.getDayEndDate": ConferenceScheduleGetDayEndDate,
1352    "event.getUnscheduledContributions": ConferenceGetUnscheduledContributions,
1353    "event.scheduleContributions": ConferenceScheduleContributions,
1354    "event.moveEntry": MoveEntry,
1355
1356    "slot.addContribution": SessionSlotScheduleAddContribution,
1357    "slot.addBreak": SessionSlotScheduleAddBreak,
1358    "slot.editBreak": SessionSlotScheduleEditBreak,
1359    "slot.deleteContribution": SessionSlotScheduleDeleteContribution,
1360    "slot.deleteBreak": SessionSlotScheduleDeleteBreak,
1361    "slot.getDayEndDate": SessionSlotScheduleGetDayEndDate,
1362    "slot.getBooking": SessionSlotGetBooking,
1363    "slot.getFossil": SessionSlotGetFossil,
1364    "slot.modifyStartEndDate": SessionSlotScheduleModifyStartEndDate,
1365    "slot.moveEntry": MoveEntryFromSessionBlock,
1366
1367    "session.getDayEndDate": SessionScheduleGetDayEndDate,
1368    "session.addSlot": SessionScheduleAddSessionSlot,
1369    "session.editSlot": SessionScheduleEditSessionSlot,
1370    "session.editSlotById": SessionScheduleEditSessionSlotById,
1371    "session.deleteSlot": SessionScheduleDeleteSessionSlot,
1372    "session.changeColors": SessionScheduleChangeSessionColors,
1373   "session.modifyStartEndDate": SessionScheduleModifyStartEndDate,
1374
1375
1376    "session.getUnscheduledContributions": SessionGetUnscheduledContributions,
1377    "slot.scheduleContributions": SessionSlotScheduleContributions,
1378
1379    "break.getBooking": BreakGetBooking,
1380
1381    "setSessionSlots": ConferenceSetSessionSlots,
1382    "setScheduleSessions": ConferenceSetScheduleSessions,
1383
1384    "getAllSessionConveners": ConferenceGetAllConveners,
1385    "getAllSpeakers": ConferenceGetAllSpeakers,
1386
1387    "event.moveEntryUpDown": ConferenceTimetableMoveEntryUpDown,
1388    "session.moveEntryUpDown": SessionTimetableMoveEntryUpDown,
1389    "slot.moveEntryUpDown": SessionSlotTimetableMoveEntryUpDown,
1390
1391    "event.editRoomLocation": EventEditRoomLocation,
1392    "session.editRoomLocation": SessionEditRoomLocation,
1393    "slot.editRoomLocation": SessionSlotEditRoomLocation,
1394
1395    "api.getSessionExportPopup": SessionGetExportPopup,
1396    "api.getSessionExportURLs": SessionExportURLs,
1397    "api.getContribExportPopup": ContributionGetExportPopup,
1398    "api.getContribExportURLs": ContributionExportURLs
1399}
Note: See TracBrowser for help on using the repository browser.